The following is supposed to give you an idea of our developer culture and values. We don't adhere to a development methodology.
We are striving to foster a transparent culture where every person feels comfortable contributing their insights. We don't want anyone to be hindered by fear of looking dumb (FOLD). If something seems complex, we should all feel comfortable saying so.
The eternal enemy of any developer is complexity. John Ousterhout, a professor of computer science at Stanford wrote a book called A Philosophy of Software Design where he makes the case that the limiting factor in software development is complexity. Here are the first two paragraphs of the first chapter, to give you a taste:
Writing computer software is one of the purest creative activities in the history of the human race. Programmers aren’t bound by practical limitations such as the laws of physics; we can create exciting virtual worlds with behaviors that could never exist in the real world. Programming doesn’t require great physical skill or coordination, like ballet or basketball. All programming requires is a creative mind and the ability to organize your thoughts. If you can visualize a system, you can probably implement it in a computer program.
This means that the greatest limitation in writing software is our ability to understand the systems we are creating. As a program evolves and acquires more features, it becomes complicated, with subtle dependencies between its components. Over time, complexity accumulates, and it becomes harder and harder for programmers to keep all of the relevant factors in their minds as they modify the system. This slows down development and leads to bugs, which slow development even more and add to its cost. Complexity increases inevitably over the life of any program. The larger the program, and the more people that work on it, the more difficult it is to manage complexity.
(If you want a digital copy of A Philosophy of Software Design, ask Liam.)
One of our most important jobs as developers is to mitigate complexity as we create software. There are tried-and-true ways of doing this:
- making the code simple in the first place,
- encapsulating the code well, and
- writing automated tests.
If something seems strange to you, please ask questions! Dig into crufty code. Don't be afraid to get your hands dirty.