The following people are permanent members of the Create:Source Code FE Team:
|André Luís||Frontend Engineering Manager, Create:Source Code, Create:Code Review, Delivery & Scalability|
|Jacques Erasmus||Senior Frontend Engineer, Create:Source Code|
|Samantha Ming||Frontend Engineer, Create:Source Code|
The following members of other functional teams are our stable counterparts:
|Daniel Gruesso||Product Manager, Create:Source Code|
|Pedro Moreira da Silva||Staff Product Designer, Create:Source Code|
|Mike Nichols||Senior Product Designer, Create:Source Code|
|Marcia Ramos||Senior Technical Writer, Create (Source Code, Code Review, Editor)|
|Evan Read||Senior Technical Writer, Create (Ecosystem, Gitaly, Gitter)|
|Nick Thomas||Staff Backend Engineer, Create:Source Code|
|Sean Carroll||Backend Engineering Manager (Interim), Create:Source Code|
|Mark Lapierre||Senior Software Engineer in Test, Create:Source Code|
|Igor Drozdov||Senior Backend Engineer, Create:Source Code|
|Vasilii Iakliushin||Senior Backend Engineer, Create:Source Code|
|Darva Satcher||Senior Manager, Engineering, Create|
|Robert May||Senior Backend Engineer, Create:Source Code|
|Marcel van Remmerden||Product Design Manager, Create|
|Katherine Okpara||UX Researcher, Create|
|James Ramsay||Group Manager, Product Management, Create|
We held an Iteration Retrospective in April 2020 in order to review past work and discuss how we could improve iteration for upcoming efforts.
Some overal conclusions/improvements
In general, we use the standard GitLab engineering workflow. To get in touch
with the Create:Source Code FE team, it's best to create an issue in the relevant project
(typically GitLab) and add the
~"group::source code" and
~frontend labels, along with any other
appropriate labels (
~section::dev). Then, feel free to ping the relevant Product Manager and/or
Engineering Manager as listed above.
Weekly calls between the product manager and engineering managers (frontend and backend) are listed in the "Source Code Group" calendar. Everyone is welcome to join and these calls are used to discuss any roadblocks, concerns, status updates, deliverables, or other thoughts that impact the group. Every 2 weeks (in the middle of a release), a mid-milestone check-in occurs, to report on the current status of ~"Deliverable"s. Monthly calls occurs under the same calendar where the entire group is encouraged to join, in order to highlight accomplishments/improvements, discuss future iterations, review retrospective concerns and action items, and any other general items that impact the group.
Expanding on the concept of Middle of milestone check-in:
The way we try to grasp how well we are doing according to the scheduled and committed set of Deliverables is simply trying to calculate the level of completeness of all of them.
We do this by tallying up:
We then compile a small report like this:
Done + Verification: 1 w1 2.27% In review: 6 w15 34.09% In dev: 6 w20 45.45% Unstarted: 3 w8 18.18% Progress: 47.73% Conclusion: ...
Progress is calculated with:
100% * 2.27 + 80% * 34.09 + 40% * 45.45 + 0% * 18.18
In the conclusion we write an interpretation of what this means and what we'll be doing to correct course, if needed.
We use weights to forecast the complexity of each given issue aimed at being scheduled into a given milestone. These weights help us ensure that the amount of scheduled work in a cycle is reasonable, both for the team as a whole and for each individual. The "weight budget" for a given cycle is determined based on the team's recent output, as well as the upcoming availability of each engineer.
Before each milestone, the Engineering Manager takes a pass and sets weights on all issues currently aimed at the next milestone by Product and triaging processes. On occasion, specific ICs can be brought to review the assigned weight. This is aimed at helping the ICs stay focused on Deliverables while working in the last week of the active milestone.
We understand weights are mere forecasts and we accept the uncertainty that comes with this.
These are the broad definition for each of the weights values. We don't use a Fibonacci-based progression but we do try to split up large issues as we understand they are by definition less accurate predictions.
When issues are Frontend only, we use the Weight feature of Issues.
When issues are both Frontend and Backend we use specific labels to support both weights in the same issue:
|1: Trivial||The problem is very well understood, no extra investigation is required, the exact solution is already known and just needs to be implemented, no surprises are expected, and no coordination with other teams or people is required.|
|2: Small||The problem is well understood and a solution is outlined, but a little bit of extra investigation will probably still be required to realize the solution.|
|3: Medium||Features that are well understood and relatively straightforward. Bugs that are relatively poorly understood and may not yet have a suggested solution.|
|4: Medium||Features that are well understood and relatively straightforward but still need a good deal of work. Bugs that are relatively poorly understood and may not yet have a suggested solution. Includes some tasks that might be hard to test.|
|5: Large||Features that are well understood, but known to be hard. Bugs that are very poorly understood, and will not have a suggested solution.|
|8: Very large||Very large features that usually require the dedication of a FE for the full length of the milestone. — Very rare, usually split into smaller issues|
The easiest way for engineering managers, product managers, and other stakeholders to get a high-level overview of the status of all issues in the current milestone, or all issues assigned to specific person, is through the Development issue board, which has columns for each of the workflow labels described on Engineering Workflow handbook page under Updating Issues Throughout Development.
As owners of the issues assigned to them, engineers are expected to keep the workflow labels on their issues up to date, either by manually assigning the new label, or by dragging the issue from one column on the board to the next.
The goal is to support the members of these groups in connecting at a personal level, not to check in on people's progress or replace any existing processes to communicate status or ask for help, and the questions are written with that in mind:
On the first week of every milestone, we have a sync-call with every IC in which they take turns at presenting their plan for their Deliverables for the new milestone.
This usually happens at the first Thursday of the milestone (at least 5 days into it) at 3PM UTC.
We have 1 regularly scheduled "Per Milestone" retrospective, and can have ad-hoc "Per Feature" retrospectives more focused at analyzing a specific case, usually looking into the Iteration approach.
The Create:Source Code group conducts monthly retrospectives in GitLab issues. These include the backend team, plus any people from frontend, UX, and PM who have worked with that team during the release being retrospected.