Table of Contents
I want to go over some basic information about software development in the real world so that hopefully you can see how some of my course designed is meant to also train you for real world tools and processes, and also just so you have some idea of how development works before you leave school.
When it comes to building a large software product over time with a bunch of developers working on different parts, requirements, planning, and collaborating is required. We try to use established software development methodologies to keep everything organized and working even while the product is incomplete.
You don't necessarily have to have this stuff memorized, but it's here for context and for future reference.
1. Software development methodologies
I am really only familiar with these two ways to design and implement software. Most places I've worked at around KC tries to use Agile Scrum or Agile with Kanban.
1.1. Waterfall
In early software development, or in places that aren't really well versed in software engineering practices, companies may follow the Waterfall method of development. Everything runs from top-down, completing a step before moving onto the next:
- Planning the entire software product and all requirements.
- Development build the entire thing.
- Testing the entire thing.
- Deploy once finished.
Some issues with the way this works are:
- If you're building a ton of code without thorough testing you will probably be missing things - it is better to test as you go.
- The client may change their mind at some step of the process, or something outside may require a change to the software, but the entire monolith has been planned already.
- Bottlenecks - Before testing can begin, development needs to finish. Before development can begin, planning needs to finish, etc.
1.2. Agile scrum
With Agile Scrum the goal is to make software development flexible and able to change as needed - thus to be agile. This includes looking at software development as a cycle that continues over time. Development is structured so that you have a series of sprints to represent this cycle, with sprints being one month or less, usually more like a couple of weeks each.
A sprint might include the following:
- Sprint design/planning - Take items from the backlog and figure out what will be worked on this sprint.
- Daily planning - Every day there is a "standup" meeting where a team's members talk about where they're at in the process. Often they answer "What did I do yesterday?", "What will I do today?", "Do I have anything blocking my progress?". Teams have a scrum-master who acts as a liason between teams and helps fix blockers, but isn't really on the specific team helping with development.
- Daily development - With a set of tickets ready for the sprint each developer will take whatever tickets are available and work on one or a small set at a time.
- Testing - Testers will take the ticket requirements and figure out how to verify that the new feature works and write manual and/or automated tests. Often the programmers will write unit tests to verify their work as well.
- Code freeze - Near the end of a sprint the code is put on "freeze" mode so that testers have some additional time to test everything without new stuff being added to the pile. :)
- Sprint review and retrospective - At the end of the sprint the team gets together to review how it went, such as "What went well?", "What didn't go well?", "What will we change for next time?".
At the end of the sprint all the new features merged in should be working and the software product should still build and run, being presentable to the client if needed.
Often the development team responsible for a set of features/tickets are the one who do the sprint planning for their work. They split out a feature into separate small tickets and estimate how much time each will take, with each task ideally taking less than 2 days. (If it would take more, it needs to be broken out into more tickets.)
See also: https://en.wikipedia.org/wiki/Scrum_(software_development)
2. User stories: Planning user needs
In order to figure out what should be added to software the designers often come up with personas for "types of customers" and build out user stories to describe what they want from the software. For example:
- AS A person about to move I WANT TO be able to look up moving companies by price SO THAT I can find a service with my budget.
- AS A moving company owner I WANT TO be able to set promotional sales SO THAT I can attract new customers.
See also: https://en.wikipedia.org/wiki/User_story
3. Development team makeup
Most places I've worked at have had many teams, with each team having a few people each, such as:
- Two or three programmers
- One Quality Assurance or Software Engineer in Test
- One Team Lead (often one of the programmers)
- One Scrum Master (shared by multiple teams)
- One Business Analyst (shared by multiple teams)
- One Tech Writer (shared by multiple teams)
(I only had a Tech Writer on my team when I worked at Lexmark, but I think they're good to have!!)
4. Development: Branches, merge requests, code reviews
Software developers use source control solutions to help manage the building of their software. In our class we will be using Git, which is a pretty common tool. Often the workflow of a developer looks like this:
- Grab a ticket to work on. (Ticket usually has a unique number you can reference.)
- Create a new branch (an offshoot from the base software product) to add new code to for the new feature.
- Back up code periodically during development, sync the branch to the server once done with the feature.
- Create a merge request, which shows your changes to the code on your branch, and you can point to your ticket #.
- Get code reviews from peers - they will review the changes and point out any obvious issues.
- After approval, the team lead merges your branch code to the main branch.
5. Testing
Often a team has at least one tester. A tester works on creating tests, whether that's writing down steps to manually test the software, writing scripts to automate testing (such as automating mouse clicks to navigate the UI, or frameworks to easily navigate webpages). They may also work on integration tests (testing the entire software together) and load and performance tests (to make sure the software runs smoothly even with lots of data/a lot of resources taken up.)
Usually the programmer for a ticket is repsonsible for creating unit tests to test the functions that they created as part of their feature.
6. Deployment
Usually there is some kind of continuous integration configured so that whenever the source control server receives new code it will build that code and run the automated tests. This happens automatically so that whenever new code is added it checks for a failed build or failed tests - if this happens, the developer must fix whatever issues they caused.
See also: https://en.wikipedia.org/wiki/Continuous_integration
If you have any other questions about software development let me know and I'll add onto this section. :)