MongoDB University Impressions
The MongoDB University Introduction to MongoDB learning path consists of a series of topical courses to teach essential skills for building modern applications with MongoDB: connecting to a MongoDB database, CRUD operations, aggregation, indexing, and search.
The learning path consists of a series of topical units:
- MongoDB and the Document Model (1.25 hours)
- MongoDB CRUD Operations (1.25 hours)
- MongoDB Aggregation (1.75 hours)
Each one of these units are comprised of videos, quizzes, and interactive labs where you connect to a Mongo database and perform relevant operations. The MongoDB pedagogical approach throughout is to methodically cover itemized learning objectives with didactic instruction. While this approach may seem thorough and comprehensive, it seems more likely to be an inefficient use of developer learning time and result in shallow, overly conceptual learning with little long-term retention. The developer learning experience could be significantly improved by addressing a few areas:
Utilize Video Judiciously
In the videos, the presenters come off as fairly robotic, reading a series of short sentences that are already shown on the screen. In the unit on MongoDB Indexes, for example, the presenter simply reads a series of statements:
Indexes improve performance. Indexes have a write cost. Too many indexes in a collection can affect system performance. Delete unused or redundant indexes.
I understand that many people prefer watching videos for educational content delivery and training purposes, but watching videos of people reading short sentences out loud feels tedious. When you make a three minute video of someone reading out loud what could be read in twenty seconds, you are missing the point of the medium entirely. In this case, I’d much rather just read a one page sheet with bullet-point lists or have a slideshow that I can click through at my own pace. Videos should be reserved for instances where learners actually benefit from being shown something.
The team at MongoDB made the choice to use a different person from their Education team for each unit. At first, I thought this was smart. If one particular personality doesn’t work for you, there is another person in the next unit with a slightly different approach. However, the writing style between the different presenters is exactly the same. This is another instance of MongoDB not actually utilizing the video medium. Having different teachers on video would presumably allow you to convey information with different styles and teaching approaches, but MongoDB has really just recruited a diverse cast to read from the same script. This is almost a satire of diversity and inclusion programs: the cast of characters all look different, but they think, speak, and approach everything exactly the same.
The more problematic thing is that it is highly unlikely I will ever return to these video resources. Since they are broken down into small video segments spaced between labs and quizzes, they are single use content that would be cumbersome to reference back to while actually using MongoDB in production. A better approach would be to tightly couple learning materials with documentation.
Refer to the Actual Documentation
It would be beneficial for introductory courses to incorporate the actual documentation in the learning content. When professional developers use a product, they often need to refer to the docs. However, it seems like web development intro courses rarely use the documentation, and only occasionally refer to it at the end of a section. Instead, these courses should encourage students to navigate the documentation with ease, as it will be a crucial aspect of their work as developers.
I’m not suggesting that the videos should be didactic presentations of the documentation. The course should be constructed as a sequence of operations and real-world challenges that developers will encounter. The videos should demonstrate how a user can address the concern by breaking it down into smaller problems or workflows that can then be addressed using the real documentation. Interactive labs give the appearance of hands-on learning, but the solutions are often just provided in code snippets on the right side of the screen. Navigating back to these labs would be highly cumbersome and unlikely. But navigating to the actual documentation that includes necessary boilerplate code is actually what developers will be doing in their day-to-day work. Intro courses should be developed with this actual workflow in mind.
Teach for the Beginner’s Mind
It is apparent that courses like this do not have enough input from junior developers. They could benefit hugely from taking a step back and understanding how to develop the content for people who are encountering it for the first time. How do junior developers actually use MongoDB? What is their workflow? Create a course that mimics that and brings it up to speed.
Intro web development intro courses too often jump right into how to implement a solution and do not spend nearly enough time describing why and when the initial problem arises and why this technology or solution exists in the first place. This is fine for a short, topical video, but the approach should be fundamentally different for a comprehensive intro course.
I think an optimal approach would be to ask: “Does the developer understand when this topic is relevant? Does the developer know how to refer to the documentation for this specific subject?
Instead of just explaining the topic conceptually (“Indexes improve performance. Indexes have a write cost.”), the videos should cover why and when a developer may need to implement the specific solution. The learning topics need to be contextualized. Does it make sense to even think about indexes on a database with three documents? Probably not. At what point does it make sense to implement indexing? Is there a specific symptom we could watch for as an indicator of when indexing will be helpful? Instead of opening a video with “Now we are going to talk about X,” it would be helpful to give some general context for why we are now talking about X.
I think the team would benefit from pulling back a little bit and looking at the technology with a beginner’s mind. Rather than approaching each topic as a “learning objective” that needs to be covered, I really wish this learning path was constructed as a series of abilities that a developer can now unlock and implement in their work in order to address specific use cases.
An Alternative Approach: Experiential, Project-Based
MongoDB already has the unit-based learning path. They don’t need to kill it. But I’d love to see them spin up a complementary, project-based learning path.
The ‘labs’ are too ad-hoc and narrowly scoped. In each of these interactive, “hands-on” opportunities, the majority of the code is already written. The assignment is to simply finish a few lines of code underneath comments. While this appears to be a “real-world” utilization of the concepts that were just covered, the actual experience is still similar to copy pasting in the answer and clicking submit. There is no time spent understanding why we are doing this in the first place or connecting this feature to the previous features we have been building.
I think there could be a much more compelling — and fun — way to optimize for long-term retention: implement the entire path within one big lab. Instead of popping in and out of a series of unrelated labs, why not teach MongoDB with a real database and series of increasingly complex operations that are not arbitrary but contextualized within a real-world use case?
Instead of someone staring into the camera saying “Indexes improve performance. Indexes have a write cost. Too many indexes in a collection can affect system performance,” use the video format to familiarize the developer with how they will connect specific problems and use cases to specific solutions. “It is taking four seconds to receive a response from the database on this simple query. What can we do to improve the response time for database queries of this nature?” Set up the problem, lead learners through the problem-solving approach, and then review the outcomes and implications.
Databases are massively fun and powerful. Many people are attracted to this field because they love solving problems. This juncture of a developer’s learning path should be hugely exciting — MongoDB enables a tremendous advance in the problem-solving value that developers can bring to organizations and their own projects.
An optimal way to teach MongoDB would be to just stick with one project and show how the developer can progressively handle more critical and complex problems that they will face in the real world. Use video when needed, but keep the primary focus on the lab environment. Refer to the documentation often so that learners develop an intuitive understanding of how to quickly use this reference material while working. Use new problems and feature requests to introduce new concepts with a clear “why”. Trust that when a developer understands why something is important, they will have the clarity and motivation to seek out the right information and implement a solution.