Tom Preston-Werner

GitHub Pages is for hosting documentation: http://defunkt.github.com/ambition/ Sourceforge and Rubyforge both provide similar services. This is nothing new. It's also for hosting static blogs: http://tom.preston-werner.com/ It's also for hosting personal sites: http://defunkt.github.com/ I love seeing creative uses of Pages. If we spent all our time worrying "what if," we wouldn't have a brand to dilute nor a team's attention to divert.

Checking your actual landing page ( https://propertywebbuilder.com ) and my opinion is... that it isn't a very good landing page. The sizing and spacing are awkward and blocky, your color scheme clashes with your images, the images are generic and tacky, everything is too big and wide, etc. Maybe because you worked on it you feel that it is a great modern style landing page, but that isn't how it reads to me (and seemingly to other people as well). Maybe you look at a SIMPLER site like https://tom.preston-werner.com/ and mistakenly equate that with a "worse" landing page. Actually though this simple page has bullet proof styling, and slapping some stock images on it like you did on your page wouldn't make it better, it would make it way worse. Rather than looking for an external factor like a "mythical uncanny valley" to explain your landing page's poor performance, look inwards at your individual styling and what could be improved.

As someone who created a language that's gotten some momentum in the past year [http://julialang.org/] and also drew the short straw and ended up making the web site, I can say that core contributors to programming languages (especially scientific ones) seem not to be particularly interested in making pretty web pages. So I kept it as minimal as possible, starting from Tom Preston-Warner's blog [http://tom.preston-werner.com]. Could we hire a designer? Sure. But that's so far down our list of priorities, it's not even funny. And who's going to pay for it? Also, even the time spent dealing with a designer (finding one, negotiating cost, signing contracts, providing feedback, etc.) is time I could be spending on making crucial design decisions, closing issues, improving core language functionality, and writing documentation. That's probably why more mature languages tend to have fancier websites. The Go guys are still super busy making Go awesome! Even if we hired a designer who made a lovely site, then someone has to maintain it. Programming languages are living, evolving things, and their web sites change. You know what's worse than a bare bones web site? A fancy designer-made web site with a bunch of changes subsequently added by an amateur who doesn't know what the hell they're doing (me). So for now, I think we'll keep it minimalist.

Tom Preston-Werner (GitHub, SemVer, Jekyll, etc.) has a great blog post about writing README files. https://tom.preston-werner.com/2010/08/23/readme-driven-development > As a byproduct of writing a Readme in order to know what you need to implement, you’ll have a very nice piece of documentation sitting in front of you. You’ll also find that it’s much easier to write this document at the beginning of the project when your excitement and motivation are at their highest. Retroactively writing a Readme is an absolute drag, and you’re sure to miss all kinds of important details when you do so.

Also recommend reading https://tom.preston-werner.com/2009/05/19/the-git-parable.html

This is the best, step-by-step explanation of how git works: https://tom.preston-werner.com/2009/05/19/the-git-parable.html

> As far as I know Redwood has no server-side rendering solution. SSR is priority number one for v2. In the meantime, a number of users use Next.js as a client that talks GraphQL to the Redwood backend. It works very well! > there is actual financial backing for Next.js Today I announced I will be providing $1M of funding for future RedwoodJS framework development this year, so now we have funding too. =) https://tom.preston-werner.com/2022/04/04/redwood-v1-and-funding.html The truth is, we can both succeed at the same time, there are so many great app ideas waiting to be explored, and different tools will work better for different situations!

RedwoodJS is an open-source project. We are in a unique position to receive funding from Preston-Werner Ventures, which allows us to develop the codebase as well as cultivate an amazing community. Although it's not a typical for-profit business model, we are sustainable and will enthusiastically continue building Redwood to v2 and well beyond. You can read more about all of that in today's blog post from Tom (aka mojombo): https://tom.preston-werner.com/2022/04/04/redwood-v1-and-funding.html

For a simple, easy to understand overview of git, nothing beats The Git Parable [1]. Every time I talk to someone starting out with Git I recommend they read it first. Once they understand Git through that lens, usually I find the rest falls into place. [1] https://tom.preston-werner.com/2009/05/19/the-git-parable.html

The thing that made git click for me was to understand the data structures that make git work. There's beauty and elegance in the implementation details of git. You can do and undo with confidence once you can translate the changes you want to make to git object transformations. To get an overview of the concepts behind git I recommend this article by one of the GitHub founders: http://tom.preston-werner.com/2009/05/19/the-git-parable.html To understand the data structures I suggest: https://codewords.recurse.com/issues/two/git-from-the-inside-out

Readme Driven Development, a term I first saw used by Tom Preston-Werner (GitHub founder): https://tom.preston-werner.com/2010/08/23/readme-driven-development.ht… I find it to be a great method of development. The core use case (what the project is and why it exists), and the public interface are so important, and often overlooked when people start a project by writing the code first. I tend to write the README in my head naturally, before I start a project, so writing it down makes sense. I also like to write the developer guide part of the README at the beginning (how to setup a development environment), so I ensure the project is easy to contribute to.

The best (known to me) informal intro into the architecture of Git is The Git Parable: http://tom.preston-werner.com/2009/05/19/the-git-parable.html

>I credit TPW for giving me words to describe this to engineers ( http://tom.preston-werner.com/2010/08/23/readme-driven-devel... ) and my high school English teachers for giving me the love of words! This so much. I find that my strong liberal arts education in high school has made me a much better developer. Things like meter and pacing are quite applicable to writing code, and like you I have only my high school English teachers to thank for that. So many of the processes around writing (good) code are similar to those around writing (good) prose, it amazes me that non-technical writing and literary analysis aren't more strongly preferred.

This is perhaps too few words to elucidate git. I appreciate that Ms. Cook links to other articles on her own site that go into much greater detail. However, I still think the best self-contained and relatively brief explanation of Git is "The Git Parable."[1] [1] http://tom.preston-werner.com/2009/05/19/the-git-parable.html

I think the Git Parable is an excellent explanation of the underlying git model. http://tom.preston-werner.com/2009/05/19/the-git-parable.html

My favorite "how it works" article is The Git Parable http://tom.preston-werner.com/2009/05/19/the-git-parable.html

I think it is because of the expectations set by Tom (mojombo). http://tom.preston-werner.com/2011/11/22/open-source-everything.html He mentioned not to opensource anything that represents core business value. A Text Editor is best set to grow when available free. Examples - VIM, Emacs, LightTable. That said, there have been hints that it might be paid ("Atom is free till beta") and Github might try to make money through it like Sublime or Textmate. Though I wouldn't worry much about Opensourcing, I might think twice to pay for a Text Editor - considering that there are really good free alternatives.

I'm pretty sure Tom Preston Warner (in particular) would disagree with you. He gave a great presentation to YC's Startup School a few years ago on the subject[1, 2]. GitHub has had one of the best jobs retaining people. Zach Holman disclosed some numbers recently[3] on his How GitHub (no longer) Works talk. [1] video: http://www.justin.tv/startupschool/b/272031754 [2] Writeup http://tom.preston-werner.com/2010/10/18/optimize-for-happiness.html [3] http://www.infoq.com/presentations/github-evolution

Sounds similar to http://tom.preston-werner.com/2010/08/23/readme-driven-development.htm… I've found writing my manual first to be a great way to define my project. I usually even keep a volatile roadmap, FAQ, etc that I update frequently as a way to manage tasks. Also helps make sure I don't let features creep in keeping me from shipping.

Pulling from an old blog post, I don't see any inconsistency. http://tom.preston-werner.com/2010/10/18/optimize-for-happiness.html > The ironic thing about bootstrapping and venture capital is that once you demonstrate some success, investors will come to YOU. When this happens you will be in a much better place to make a more reasoned choice about taking on additional capital and all the complexities that come with it. Talking to VCs with some leverage in your back pocket is an entirely different game from throwing yourself in front of a conference table full of general partners and trying to persuade them that you're worth their time and money. Power is happiness.

You're right. In his blog post about the talk[1], he makes it clear that his emphasis is on bootstrapping to profitability. "The ironic thing about bootstrapping and venture capital is that once you demonstrate some success, investors will come to YOU. When this happens you will be in a much better place to make a more reasoned choice about taking on additional capital and all the complexities that come with it. Talking to VCs with some leverage in your back pocket is an entirely different game from throwing yourself in front of a conference table full of general partners and trying to persuade them that you're worth their time and money. Power is happiness." [1]: http://tom.preston-werner.com/2010/10/18/optimize-for-happiness.html

Swagger goes part of the way towards solving this problem, at least for REST apis: http://swagger.wordnik.com/. It's a little annotation heavy for me - I'm guessing you want something that's generated almost entirely from code introspection. And it obviously doesn't work for library code. But I think the UX for an implementer is a great one. I do love Readme Driven Development (http://tom.preston-werner.com/2010/08/23/readme-driven-development.htm… and Github helps here with its per-directory readme displays, but keeping up with these over the duration of a project is obviously a problem, as you note.

I recently switched my site[1] over to Jekyll, hosted on GitHub Pages, and am very satisfied. The easiest way to get started is to fork Tom Preston-Werner's Jekyll blog[2], modify the layout as you'd like, and then populate your blog posts. This way, you can jump right in and then learn more about the intricacies of Jekyll as you go. 1: http://blog.metamorphium.com 2: http://tom.preston-werner.com/

The key that makes things click for me is, the Commit is the most important 'unit' of Git. Tags, branches, pseudo-refs like HEAD are all just mutable or immutable (like tags) pointers to commits. http://tom.preston-werner.com/2009/05/19/the-git-parable.html is absolutely worth your time if the above statement didn't trigger a lightbulb in your head

My favourite one is The Git Parable. It walks you through the steps you'd take to make you're own DCVS. Once you understand this, reading the man pages makes a lot more sense. http://tom.preston-werner.com/2009/05/19/the-git-parable.html

Thanks -- great article. This is the most readable and straight-forward explanation of git's internals that I've seen (and I've read a bunch of articles/books/etc. looking for resources to help others learn git). I'd also recommend The Git Parable (http://tom.preston-werner.com/2009/05/19/the-git-parable.html) for anyone who hasn't read it. Different focus, but also helpful for understanding git's philosophy.

We're really coming full circle here, eh? Next thing you now people will start advocating the waterfall method again. More seriously though, it all depends on what you're writing. Sometimes TDD works best, README-driven development (http://tom.preston-werner.com/2010/08/23/readme-driven-development.htm… is really nice for certain projects, sometimes top-down is a good thing and sometimes just hacking away without having a clue about what you're doing turns out surprisingly well. There's way too much discussion about methodologies and way too little about when they shine.

In your blog post (http://tom.preston-werner.com/2008/10/27/looking-back-on-selling-grava… you say "As it’s become one of my favorite parables, I’ll save the details of how I came up with the idea for Gravatar for a future post." When will that post happen? :-)

> I don't know how GitHub got a head start, Check out Tom's story about it: http://tom.preston-werner.com/2008/10/18/how-i-turned-down-300k.html One of the things I love about the Ruby community is that it truly embraces change. Rubyists (and particularly Rails hackers) jumped on git, and since GitHub was built by our own, it was supported heavily by Rubyists. Engine Yard gave them free hosting for a long time, we blogged and told all of our friends, and like any social network, it just grew from there. It also helps that it's an awesome service.

And an excellent read to learn about Git is http://tom.preston-werner.com/2009/05/19/the-git-parable.html, from a GitHub cofounder.