← Home Books Archive Photos Replies About
  • The only two things you get out of academia or bootcamp

    Whether you’re learning how to code at a bootcamp or through academia, there are only two things you ultimately get from the experience.

    First, you get an amazing network of friends who are committed to helping you early in your career.

    Your institution’s alumni program offers assistance with resumes, job searching, online webinars, and an institutional name that gives you something in common with other graduates. Some programs partner with specific employers, waiting to hire graduates.

    Sometimes the alumni program has a time limit on it, particularly with bootcamps. Take advantage of this. You’ll never have anyone else who can be this helpful in finding you a job.

    Jen at Frontend Masters, assisting two students with their code.

    Second, you learn how to learn technology.

    Your tech education starts expiring while you’re in school! Techniques you learned early in the program may be out of date by the end. (They may also teach you dated techniques, but that’s a rant for another time.)

    If you don’t keep learning and practicing your tech skills, you’ll be out of the field. Within 6 months, your education is dated enough that it will be hard to jump into the workplace. In a year, you’re completely out of date and will have a significant learning curve to jump back in.

    But I’m watching video education from X provider in class – I could do this on my own without school!

    True. But you don’t get the two items above, which are extremely valuable to getting into the field quickly.

    Furthermore, someone curated those resources. They told you what resources had the most value. They are teaching you where to look when it’s time to learn a new skill. They are choosing resources that are (hopefully) factually based, up-to-date, and reflect current thinking in the field. Anyone can post videos on YouTube and post courses to Udemy… and they frequently do. Boasting 75 hours of learning time does not make those materials good. It just makes them long.

    When people say you could learn X on your own and you don’t need school, they are correct. School offers you the structure and accountability to get it done, though. And you’ll never get the resource curation, alumni network, or practice in learning that you get at school. Consider this as you’re trying to decide how to get into the field.

    → 11:04 AM, Apr 21
  • HTML is the hardest language to master

    An observation seen on Mastodon:

    Mastodon toot from Vasilis: Whenever I look at source code of almost all websites out there in the wold I have to conclude that not just my students, but just about every web developer finds HTML the hardest language. Now I wonder: Why is HTML so hard? Maybe it's because languages like CSS and JavaScript have much more immediate visible effect? Could be. And maybe, since the effect of HTML is largely invisible, at least pretty subtle in most common contexts, people simply don't notice it?

    My responses:

    Except for perhaps you and me, no one really teaches HTML. Students are told here’s the syntax, here’s p, a, span, div. Apply these elements and see how this looks. Right from the beginning, students are taught that HTML is about looks, not meaning.

    Because HTML-only web pages look boring, almost immediately students are taught CSS, which (mostly) overrides the HTML look. Students conclude that HTML doesn’t matter as its look is overridden by CSS anyway.

    Then when they get to JavaScript, they learn that HTML is merely a structure on which they hang their JavaScript events and such.

    Prior to 2008 or so, most devs came to the web via HTML and CSS, then JavaScript. We taught separation of powers and spent more time on HTML. We taught HTML is not about the look.

    After 2012, most devs came to the web through JavaScript first or almost first. Almost no time was spent on HTML and CSS because future devs learned that JS was the exciting part.

    Only now after 10 years of this relentless emphasis of JavaScript are devs realizing that HTML and CSS are 2/3 of the front end and may deserve some time and attention. Only with the recent emphasis on accessibility are devs finally understanding that HTML has some useful characteristics that come for free. There’s no need to program each div with aria this or role that. And 75 layers of nested divs may be a bad thing.

    → 12:35 PM, Nov 24
  • Flexbox Froggy is a horrible way to learn Flexbox

    Interactions on discussion boards hundreds of times a day…

    Person 1: OMG Flexbox is so hard, I can't understand, can anyone help me. Person 2: Have u played the flex frog game... simple but helped me get some basics. flexboxfroggy.com

    Flexbox Froggy is not a good way to learn Flexbox. Yes, it asks students to recall values for properties associated with Flexbox. Yes, it gives you an adorable visual for how those properties and values impact the layout of frogs on lily pads.

    Screenshot showing frogs not quite aligned with their lilypads. Level 8: Frogs are not quite aligned with their lilypads to start. After typing in the appropriate Flexbox code in question, the frogs align with their lilypads. After typing in the appropriate Flexbox CSS properties and values, the frogs align to their lilypads. Adorable.

    Level 8, shown above, involves the flex-direction CSS property, which has a series of possible values. All of this is explained above the window for typing in the appropriate code to align the frogs to the lilypads.

    Flexbox Froggy level 8, explaining the flex-direction property, its possible values of row, row-reverse, column, or column-reverse, and a blank to type in the correct property-value pair.

    Is the game fun? Absolutely! Students engage with the game quickly and easily. (Yes, also Flexbox Zombies and Flexbox Defender, which are similar games to teach Flexbox properties, with similar flaws to Flexbox Froggy.)

    Do students know Flexbox once they reach level 24, the last possible level? No.

    But it teaches CSS properties! That's awesome!

    Teaches is a strong word.

    Flexbox Froggy asks students to remember specific CSS properties and the appropriate value to solve layout problems.

    Students may understand or recognize where to place these properties to achieve prescribed layouts. Levels 1-23 all tell the students which properties will solve the presented layout problem. It does not always present the possible properties, asking students to remember those properties.

    Level 24, the last level of the game, is unique in that it asks students to apply any of the properties to solve the final layout problem. This is the only level where there are possible incorrect properties provided.

    Why did you emphasize remember, understand, and apply?

    Because these words are the basis of Bloom’s Taxonomy, a way of describing levels of learning and their depth.

    Bloom's Taxonomy pyramid, showing the levels of remember, understand, apply, analyze, evaluate, and create. Armstrong, P. (2010). Bloom’s Taxonomy. Vanderbilt University Center for Teaching. Retrieved October 28, 2022, from https://cft.vanderbilt.edu/guides-sub-pages/blooms-taxonomy/.

    Applied to the coding world, these first three levels of Bloom’s refer to concepts like:

    • recalling syntax
    • remembering HTML elements and attributes, CSS properties and values
    • understanding what those elements, attributes, properties, and values mean, and describing their impact on some code
    • filling in partially solved coding problems with appropriate lines of code to make it “work”

    Sounds basic, no? That’s because it is. What if we had some other formats to truly bring learning to the students once they were introduced to the Flexbox properties and values?

    • What if we asked students to solve problems without giving them the appropriate properties to use?
    • What if we didn’t provide a list of values?
    • What if we didn’t imply how many lines of CSS it would take to solve the problem?
    • What if we gave students the wrong code and asked them to fix it to achieve the layout?

    Finally, consider Flexbox’s critical parent/child (or flex-container/flex-item) relationship in HTML elements. Depending on where display: flex; is declared, that HTML element becomes the flex container. Its immediate descendents are flex items. Grandchildren and deeper descendents are unaffected. This directly impacts the styling of the page and is one of the biggest overlooked and misunderstood concepts when learning Flexbox. However, Flexbox Froggy never touches this discussion, focusing mostly on flex container properties. (Indeed, order, a property that specifically applies to children, is mixed with the parent properties. This amplifies learner confusion as this property “doesn’t work” when applied to the parent.)

    Well, ok, but I totally learned Flexbox with these games

    Try my CodePen which emulates Level 24 in Flexbox Froggy. Match up the colors in the appropriate layout where the comment indicates. Can you do it? If not, why?

    “Uh, I’m not a CSS expert.” Mmm hmm.

    What are you leading up to, Jen?

    If we look at almost any “teaching resource” for learning code, you will find similar problems. Coding instructors are all over the remember, understand, and apply levels of Bloom’s Taxonomy.

    Then the instructors immediately jump you to create. “Now that you know everything about Flexbox, go lay out a web page. Have fun!”

    What happened to analyze and evaluate?

    These are the levels where deep thinking happens. Now that you have a general idea of how a concept works, it’s time to dig in further. Do you really understand what was taught to you? Can you predict what happens if certain properties or values are applied to a layout? Can you debug incorrect code? Can you provide an explanation about why this code works – or why that code doesn’t?

    This is what’s missing in today’s coding education. It is assumed students are equipped to do this work on their own. It’s assumed they know this is what comes next, and it’s assumed that they will do it.

    Unfortunately, students do not know that this is what they should do next, and they don’t know how to ask these questions. The instructor must lead through these levels, increasing student independence, before turning students loose on their own creative projects.

    Expect to hear more from me about this over the coming months.

    If you want to hear more about how to teach well online, be sure to subscribe to my Substack newsletter that covers these topics.

    → 4:26 PM, Oct 27
  • 2021 retrospective

    Time for the 2021 retrospective on what was accomplished this year. To what may we point as evidence of work completed?

    Harvard Extension School

    My time ended at Harvard on June 30. During the spring term, I taught my final courses, including:
    • Modern & Mobile Web Design 2: Sass, CSS variables and calc, print stylesheets, advanced media queries, meaty final project (students built their own responsive design framework)

    • Intro to CMS: This popular WordPress project course had students building 6 sites during the term and planning 1 site, including e-commerce, custom fields, custom theming, and a final project site.

    • Designing Stories for the Web: Taught with Martha Nichols, a journalist, this course was about learning to write well for the web and getting your stories posted online in WordPress. So far as I’m aware, no one else is teaching a course like this one.

    In addition to the teaching work, I took the educational video course (which was excellent) and finished my certificate in Learning Design and Technology. This was a series of 4 courses, including an intro to instructional design, adult learning theory, video editing, and a course in online course design.

    Certificate in Learning Design and Technology.

    LinkedIn Learning

    I've worked with LinkedIn Learning since 2008, when they were Lynda.com. Historically, I'd prep 2-3 courses over a period of 4-6 months, then travel to California to record them over a week or so. However, the pandemic changed everything. These days, I prep and record about one course per month, starting about the middle of 2020. Here's a list of all of the courses that were released in 2021:
    • CSS: Display, a short course devoted to a single CSS property.
    • HTML & CSS: Linking. How much is there to say about links? A ton, actually – navbars, links, buttons, and all of the associated styling.
    • Learning Editor X. Editor X is a web design tool from Wix, targeted at graphic designers who want to make sites without code. It fills a gap that Dreamweaver used to fill. Webflow is a direct competitor.
    • Semantic HTML and CSS Code Challenges. A series of 12 challenges to practice semantic HTML and CSS coding, including Flexbox, Grid, and navbars.
    • Joomla! 4 First Look. My first Joomla course in 5 years looks at the most recent Joomla 4 release, highlighting the latest features.
    • Learning Wix. I first recorded this course in 2019. This is an update.
    • HTML and CSS: Creating Navigation Bars. An in-depth course in making responsive navigation bars, including Flexbox layouts, reordering links, centering the logo, dropdowns, hamburger buttons, and other crazy tricks with HTML and CSS - no JavaScript required.
    • No Code Solutions for Websites and Apps. This is an update from 2020. To the original 8 no-code technologies, I added another 11 technologies to give you an overview of the exploding no-code space in web design and development, automation, membership, and native apps.
    • Learning Webflow, an update of the course I recorded just before the pandemic. This one covers the latest Webflow interface, building a site from scratch.
    • No-Code Web Design Weekly. Formerly “Accidental Web Designer,” this course releases a short weekly video about what’s happening around the no-code space. It provides tips for content, marketing, and technology.

    I’ve already recorded two courses for release next year, including a more in-depth Joomla 4 course, and an introduction to web design and development.

    Here’s a still shot of the temporary dining room recording space I set up for the web design course.

    Jen in her temporary dining room studio, recording for LinkedIn Learning.

    Frontend Masters

    Frontend Masters is much more about hard-core programming than it is about no-code or UX. I recorded two courses with them this year, with a third to record in March next year.
    • CSS Grid & Flexbox for Responsive Layouts, v2. I recorded this course originally in 2017. Finally this year, I updated this with the latest Flexbox and Grid technologies.
    • Getting Started with CSS. This is a project course, building a portfolio using basic HTML and CSS. We use responsive design, CSS grid, Flexbox, and CSS variables to put the site together. It’s great practice for those who are wanting to strengthen their CSS skills.

    Here’s a shot of me teaching at Frontend Masters in August, explaining something for the camera.

    Jen teaching at Frontend Masters.

    Other projects

    This was the bulk of the work I did in 2021, but there was other work as well.

    Knowing that I was ending my relationship with Harvard, I signed up for an educational video course. At the same time, I coordinated with LinkedIn regarding appropriate equipment for configuring my studio space. I now have a dedicated room in my home for making video, including a teleprompter, DSLR camera, Yeti X mic, and a nice background for recording. Jen's video studio has a teleprompter, camera, and nice backdrop.

    As a result, I started to dabble in making more YouTube videos and doing some live streaming sessions. They were all really fantastic to do. I’d like to do more, but as you can see above, I’ve been too busy doing other things to spend much time here… so far.

    Other various “other” highlights:

    • I’m serving as an advisor to 2U’s UX/UI Bootcamp program, talking with them about curriculum periodically.
    • Erika Lee and I wrote #30DaysOfHTML and #15DaysOfCSS. These were free email series that were turned into ebooks. They were a ton of work but helped us build a substantial mailing list.
    • Erika and I turned our reflection on #30DaysOfHTML into conference talks, speaking at both PSEWeb and at HighEdWeb with our talk “30 Days of HTML: Lessons Learned Presenting Training by Email.”
    • Spoke at No Code Conf 2021, talking about planning no-code websites and apps. I gave away some awesome worksheets to walk you through the process.

    Next year

    Does the craziness end? Nope.
    • LinkedIn and I have outlined 8 courses for 2022, but that only takes us through August. 😉
    • Frontend Masters and I have scheduled “HTML Semantics & CSS Selectors ” to record on March 15.
    • I’m starting to work more with other software companies to create training specifically for them.
    • I’ve also got my own training platform ready to build, with the first course likely to release early next year.

    Keep watching! There will be much more teaching from me coming in 2022 in the realm of HTML, CSS, UX, and no-code technologies.

    → 2:17 PM, Dec 8
  • Tell students what isn't important to worry about in the assignment

    Instructor labels –

    Green circle = the assignment

    Gray circle = what students think is important

    Include a section in the assignment that clearly spells out what you DON’T care about for grading. It’s as important as the rubric you use for grading.

    At least perfect the right thing. pic.twitter.com/nTtyT5gQuE

    — Janis Ozolins (@OzolinsJanis) June 17, 2021
    → 7:15 AM, Jun 17
  • I'm back!

    #30DaysofHTML ended 2 weeks ago. My last teaching semester at Harvard ended yesterday.

    In my educational video course, where I was a student, I created a video reflecting on #30DaysofHTML. youtu.be/R9WW-KlKV…

    I’m returning to blogging shortly, now that I have some time.

    Also, I need a job. My Harvard teaching gig is up on June 30, but there isn’t much for me to do between now and then.

    → 10:39 AM, May 16
  • How to make HTML exciting again

    #30DaysofHTML banner graphic.

    Today I received the best compliment on my #30DaysofHTML course, even before it launches.

    I don't know how you've managed it, but you've gotten me all excited about HTML.

    — ოarῐa ᥨaῃ𝙜әr 🚁😷💉🇺🇸 (@mlanger) April 1, 2021

    This gets to the heart of why I started this challenge and my thinking behind it.

    How HTML is normally taught

    HTML is the scaffolding behind a web page. It’s as exciting as framing a house, or [playing bass or drums in a rock band] (https://jen4web.substack.com/p/use-the-full-frontend-or-create-junk). In other words, there’s some artistry, but it’s underappreciated by most. Done right, it’s in the shadow of way more exciting and interesting elements of the project. However, without it, nothing else matters – HTML is foundational to a website.

    When developers teach new developers HTML, it’s presented as a necessary evil. As little time as possible is spent on it, because everyone wants to get on to making things pretty and interactive – neither of which is a thing with HTML. Quick quick, here’s a tag, here’s an attribute, open/close things – whew, let’s move on.

    As a result, HTML is the mushroom of the web world. It’s kept in the dark, and it eats a lot of crap by people who see nothing to love.

    I love mushrooms

    The purpose of the Hypertext Markup Language is to identify the parts of the web page: paragraphs, lists, headings, links, addresses, quotations, and so much more. How many times have I said this sentence in 20 years of teaching?

    But finally, I made a connection: HTML is intimately tied to the story of the website.

    Everyone wants to be heard and understood. Everyone wants their story heard. Great HTML is the way to communicate your story to the world.

    When I was 14 months old and hungry, I would pull on my mother’s pant leg, point to the counter looming over my head, and grunt, “Cookie.” (Or so my mother says. I do not remember.) She would respond by giving me fruit, crackers, a bowl of dry Cheerios, or whatever else a 14 month old eats. Not a cookie, no matter hard I tried. Or she’d tell me it was almost dinner time and go away and leave her to finish it.

    Consider that your crappy HTML is telling this same story. If your website is nothing but one < div > after another, you’re just saying COOKIE COOKIE COOKIE. You’re 14 months old, with a limited grasp of vocabulary.

    Cartoon  - semantic HTML overwhelmed by divitis

    Telling the wrong story

    So. How do you convince developers, who just love everything pretty and interactive, that their framing sucks and doesn’t work? Their code that sits on top of it works just fine. Framing is SO BORING.

    Well, accessibility, of course! It’s absolutely critical. Accessibility should start at the beginning. It should always be incorporated in the site. Good accessibility starts with meaningful HTML.

    But – what the accessibility advocates are doing is not effective to get developer attention. They are, unfortunately, ignored for the most part.

    We’ve (maybe) gotten (some) busy developers to feel guilty about their bad HTML. But changing it takes effort. Learning what HTML elements are available takes time and research. Time that could be spent learning the latest JavaScript framework.

    Time for a new story with new framing.

    #MakeHTMLExcitingAgain

    If we focus on HTML’s syntax, that’s not interesting. What’s interesting is the meaning conveyed behind the elements. Why choose one element over another? How does that element contribute to the website’s story?

    30DaysofHTML incorporates the following concepts:

    • Focus on the meaning behind the elements. When should something be used or not used?

    • Don’t overwhelm with all of the edge cases and complexity. Provide just enough information to feel like you know a little bit, and provide links to everything else.

    • Identify any misconceptions about the element. HTML looks like English. The < address > element, for example, looks like it’s for a postal address. However, it can be used for any contact information associated with an article or website author, including phone numbers, email address, social media links, or even geographic coordinates. Who knew that? That’s interesting and fun and different.

    • Remove the pretty and interactive, so learners are forced to focus on the scaffolding. We aren’t concerned with cross-device presentation or UX or anything else. It’s black text on a white page. There’s nothing else to do here… by design.

    • Encourage application, reflection, and discussion. Not only should there be a little reading, but there should be some examples and problems to try too. Maybe the occasional quiz. Encourage readers to share their work and comment on each other’s markup and approaches. Put the discussion on the meaning we’re trying to convey.

    • And finally, make it fun. Make some fun graphics, throw in a few emojis, use all of the web writing techniques to break up content with headings and lists. Write in a fun and informal style.

    Hook 'em with a hook

    ["< address > should be used for addresses. You guessed that already. But what kind of addresses, and in what context?"] (https://jen4web.substack.com/p/address)

    Draw the reader in. Make them curious. Conflict is interesting. The lure of something that perhaps you don’t know is intriguing.

    I also sent out a [“Night Before”] (https://jen4web.substack.com/p/twas-the-night-before-30daysofhtml) email, explaining what to expect and how it will all work. This sets anxious learners at ease, and it sets expectations and generates interest. It also sets metrics for what success looks like.

    Give them a familiar format

    • The “X Days” format is popular at this moment. People talk about #100DaysofCode and #100DaysofNoCode and such. Why not #30DaysofHTML? Fortunately, it explains everything you need to know in the hashtag. 30 days, talking about HTML.

    • Email is the format for delivery. It’s simple, easy, and everyone has it. Using Substack, I also create a website, and it has interesting discussion features for sharing work.

    • In Silicon Valley speak, “reduce friction.” The email goes in your inbox. You read it when you’re ready. Another appears tomorrow. You’re getting 30 emails in 30 days. What’s not to love?

    Time to start!

    This is the start of my 30 day journey. I hope to learn more about HTML, but mostly, I hope to learn more about offering instruction in this format. What works and what falls flat? What is the response? What would I do differently next time?

    I’ll write more about this in May.

    → 11:29 AM, Apr 1
  • Teaching Reflections #13: Professor as a bad video-maker

    This week’s reading: [Academics aren’t content creators, and it’s regressive to make them so] (https://www.timeshighereducation.com/opinion/academics-arent-content-creators-and-its-regressive-make-them-so)

    A few quick snips from the article:

    The philosopher John Dewey told us that an educational experience – what he called a community of inquiry – requires a cognitive presence (the learner), a social presence (the learning community) and a teaching presence (the professor).
    By Dewey’s definition, if our professors spend their time editing videos instead of engaging with students, we cease to even be “educational” institutions. A video made by a professor for only their class is akin to the single-copy, handwritten book disseminated to just one room of people. It is regression, not progress.

    I think the argument the author is making is this:

    • Dewey says good learning involves 3 elements: learner, learning community, and instructor. This is a virtuous circle. All three elements feed on each other.

    • If the instructor must spend more time making (bad) video, they have less time to spend with learners. The video is often bad, because instructors are usually not filmmakers. “Bad” may be bad production, but it may also be bad storytelling in the video.

    • If the video is bad, then the learners will go elsewhere to get content, fracturing the community.

    • Without all three elements in place for a good learning experience, university education is simply overpriced.

    The practical side of this

    I also make a lot of professional video for LinkedIn Learning and Frontend Masters.

    In the past, I’ve tried to use these videos as the basis for my class. The students were extremely unhappy, because they could get their own subscription for pennies on the dollar of what they were paying for my university course.

    They prefer my less polished, less produced, lower quality video, because they felt this was a better value for their dollar. Why?

    Because they feel connected with me when I make a video for them. Students feel like they know me when I’m being my normal goofy self on camera. I have less of a personality when I’m on camera at LinkedIn. Professional polish and all that.

    Video as textbook and analysis

    Content can enable learning, but it cannot provide an education. Similarly, content is not our core value. There is a long tradition, going back to the printing press, of universities outsourcing their content provision to the textbook: an expensive relic, now replaced by largely free content on the internet. This is progress. Education should be better than ever, as we are now able to point at myriad incredible resources, possibly on the web, perhaps in our library, where we act as content aggregator, not creator. Creation is done when we have our researcher hats on, not our teaching hats.

    In the old days, we read the book before we went to class, where the information was discussed and interpreted.

    Today, video is asked to do both of these things at once: provide the information of the textbook AND provide the discussion and interpretation. The author thinks that professors spending their time making the textbook is a waste. Find other resources online, have the students use these as the textbook, and then provide interpretation and discussion in class.

    What if we had some type of vetted and reviewed video that we could incorporate in our courses? Then we have an effective textbook for our courses, and again, the professor brings the interpretation and meaning to the material.

    But I can't make YouTube-style video, so my stuff isn't engaging!

    I don’t believe this at all, because the argument here is the technology should drive the content. In other words, the students won’t watch without music, jump cuts, and crazy graphics.

    What if we had good content, making a reasonable video that tells a good story but with much less flash? What if we engaged students through discussion and collaboration?

    Remember the original argument: If the video is bad, then the learners will go elsewhere to get content, fracturing the community. However, “bad” is not defined.

    Bad video could mean bad production for sure. But it could also mean:

    • The instructor is overwhelmed trying to make technologically interesting video, reducing time to engage with students.

    • The students are not engaged with the instructor, so they go elsewhere for more entertaining content.

    • Dewey’s community of inquiry is fractured.

    What if instructors instead spent their time on making a good story, recording it the best way possible, and engaging students in discussion and activities? Rather than putting so much emphasis on video, put more on the activity and engagement for a better learning experience.

    → 11:49 AM, Mar 13
  • Teaching reflections #12: Paint-by-number as mental model

    Remember paint-by-number as a kid? There was a black and white drawing of something, sprinkled with numbers. The numbers correspond to the paint colors. Match the paint color to the numbers in the drawing, and presto, instant masterpiece.

    Sample paint by number graphic.

    This is the [mental model] (https://jamesclear.com/feynman-mental-models) of many people creating websites, flyers for the bake sale, and other digital communications. Find the template you need, drop in your own information, and presto, instant masterpiece.

    Only in both cases, it’s not really a masterpiece.

    With paint-by-number, painters get the joy of doing the painting without doing the work of visualizing something and mastering painting technique to produce the thing.

    With a Microsoft Word template, there may be a match to what the user wants to convey. An event flyer to hang in a coffee shop or library contains all of the same information: event title, time/date/location/cost, brief description of what happens and what will be experienced, contact information for questions, and an eye-catching graphic. Of course, the flyer looks similar to other fliers on the bulletin board, because everyone is using similar templates. But it may accomplish its goal.

    With websites, templates provide a way for many to structure their content. They don’t quite know what to say, or how to say it, but they need a website. They pick a template, fill in the information to the best of their ability, and hope it works well enough to accomplish their goal(s).

    Creating a method(s) to guide someone through the thinking process about a problem at hand is incredibly difficult. We get distracted by the “edge cases,” the 20% of cases when the process doesn’t work, rather than the 80% of cases where it does.

    Refining the method to a fill-in-the-blank document, workbook, or template is another layer of abstraction where another 20% of cases are lost along the way.

    Structured thinking about a problem is really difficult. If you can refine your methods for approaching a problem into a paint-by-number solution, people will pay lots of money for it, even if it’s not perfect.

    → 12:02 PM, Mar 5
  • Teaching reflections #11: The turn-in sheet

    In recent years, I’ve started creating “turn-in sheets” with my assignments in academic land.

    My assignments spell out what I want students to do for a graded project.

    The turn-in sheet structures their answers. It ensures that they’ve hit everything that I wanted them to address in their work.

    Originally, I asked students to do this to streamline grading. When I ask for use of certain structures or functionalities when building a web page, I do not want to dig through each site to find the thing. I definitely don’t want to dig through tons of code to find relevant lines. The turn-in sheet asked the student to tell me where all of the things were that they needed to address in the assignment.

    Later, I realized these turn-in sheets serve more functions than this.

    • Student anxiety is reduced, because they know they’ve addressed all aspects of the project by completing the turn-in sheet.

    • Students were more likely to reflect on their work, because it was clearer to them what they accomplished when it was formatted well.

    • It helped to cut down on cheating. This was completely unexpected! When students have to explain where to find an example of X programming structure, they must understand the code they steal. I still remember the student who stole a 12-column layout and claimed it was a 4-column layout. We caught it because the student didn’t understand the stolen code and pointed us to exactly where the plagiarism happened.

    Turn-in sheets and course workbooks help to make intangible skills like programming feel more real. They organize thinking. And they may make your grading life easier, too. Try this for your next course.

    → 12:38 PM, Mar 3
  • A video is not a course

    I’ve created “courses” at LinkedIn Learning since 2008, when the company was called Lynda.com. Lynda.com was one of the earliest, if not the first, video training companies out there.

    Their course format is a series of short videos. One video segment may lead into another, but fundamentally, each segment stands alone as a unit. After (theoretically) watching the videos, you receive a certificate of completion which you may attached to your LinkedIn profile.

    Theoretically, because you can get this certificate simply by streaming the videos in the background, on mute.

    Theoretically, because there’s no transference of skills happening to one’s own projects or situation, no reflection on the learning process, nor is there a meaningful evaluation of learning for either the learner or the instructor. LinkedIn Learning is aware of this issue and they continue to work on ways to solve it.

    However, the genie is out of the bottle, so to speak. The LinkedIn Learning “course” has become a misnomer that others try to emulate.

    Photo by Karolina Grabowska from Pexels

    This is not a course

    In the explosion of online courses offered all over the internet, a “course” is now a series of videos hidden behind a login. Pay your money and get a handful of overproduced videos that cover your area of interest.

    Then the creators wonder why students aren’t learning the material, or wondering why sales have dropped. Currently, creators turn to more bells and whistles in the videos, more animation, more attempts to make “edutainment” rather than solid education.

    Even if your course is an asynchronous, instructor-absent course, where students move through it at their own pace, you need more than video to truly make a course.

    When videos become a course

    Videos are awesome for demonstrating something. However, they’re terrible for transferring knowledge to a new environment. They’re not good for measuring what you’ve learned. Consider how often you watched someone do something and you think, “that doesn’t look so hard.” Then you try it, and you quickly discover that you have no idea what you’re doing.

    Yes, have videos in your course. No, videos aren’t the whole course. You need more to round out the learning experience. Here’s some suggestions.

    Quizzes and games

    Add self-graded quizzes to evaluate student’s assimilation of the video. These don’t have to be standard-issue multiple choice. Consider matching games, categorization games, and formats that involve photos, not just words. This type of evaluation is best for terminology or other behaviorist “you just gotta know this” material.

    I do it, we do it, you do it

    In your video, demonstrate how to do the thing you’re teaching. Ideally, students are following along with you, doing the same thing.

    Now provide your students with the assets they need to do the same type of thing on their own. You provide the structure to think about the problem, the goal they’re trying to achieve, and any boundaries and guidelines for where they should focus their attention. Follow this up with a video explaining how you solved the problem. Bonus: have a discussion thread where students may post photos or links to their work, along with a brief reflection – what went well? Where did they get stuck? What do they still not understand? What would they do differently next time?

    Finally, invite the students to do the thing on their own. Provide a separate discussion thread where they can show off their work. Again, encourage reflection, not just “this is my thing.”

    The middle step is the most important, because this is when transference happens. By giving them a small project with everything they need to succeed, this is where students gain confidence or realize they need more help in a certain area. They get a sense of what’s required to do the thing on their own.

    Incidentally, the middle step is the piece that’s missing in almost every course out there. It’s definitely missing in every software course. And it’s super critical for understanding how to program.

    Workbooks provide structure

    When students learn something new, they’re not only learning the buttons to click, or the syntax, or the structure. They are also learning the organizational tools and thinking processes that go with the thing they’re learning.

    This is one of the most overlooked aspects of teaching. Students of all abilities and intelligence have an issue with this. My Harvard students had as difficult a time knowing where to start a project as students did at any other university where I’ve taught.

    Give people a structure for thinking about the problem at hand. If it’s a 5-step process, the workbook contains those 5 steps written out, along with whatever questions they should address and a space to write. Include reflection questions. Include suggestions for making the activity more challenging or less challenging.

    Surprisingly, even in our digital age, people do not mind printing a workbook and writing all over it. In fact, many prefer this methodology, because they feel like they have a tangible asset after class is done.

    Hopefully some or all of these tips help you raise your online video series to a full course.

    → 12:23 PM, Mar 3
  • Teaching reflections #10: The same material must be re-discovered across disciplines

    If I had to describe my [T-shaped skills] (https://en.wikipedia.org/wiki/T-shaped_skills), I’d say my depth is in HTML/CSS and user interface design. Across the top, you’d find planning websites and UX, teaching skills, instructional design skills, marketing, and general technology skills – the ability to look at new software, figure it out, and apply it to a problem.

    As I move into the no-code world, I’m watching a new group of people relearn the issues we already learned and understand well in the professional website world, the marketing world, and in the world of UX.

    Today I watched someone define a target audience as “non-developers.”

    Cool. We’ve left out the 0.3% of the population who are coders. That leaves 99.7% of the world left as a target audience. This is too broad.

    Defining and targeting an audience for products is something already well-known to the world of marketing and user experience. However, the no-code world doesn’t know this work exists and has no idea how to apply it to what they do.

    We see this in the coding world. People complain about how tired they are about coding solutions to their problems, maintaining those solutions, and so forth.

    However, if you mention “no-code” to the coding world, they have no idea what you mean. They may also dismiss this out of hand as too trivial for their attention.

    For those who are looking at new emerging sectors, see if you can identify what that sector currently struggles with knowing and mastering.

    The no-code space current worries with user experience, marketing concepts, and project management. “Agile methodology for no-code” is a no-brainer for this space. No-coders need to know project management, but everything is currently framed with coding in mind.

    User experience is framed with code in mind too, even though UX is a no-code world! What happens if you plan a product and hand it off to no-coders to implement? Nothing. It’s the same process you’d use for coding. But when you’re not using the language your audience speaks, then it feels like your concepts are inaccessible and unintuitive.

    Speaking to your target audience is everything. When knowledge is locked up in the jargon of a specific discipline, it’s not transferable to others.

    How can you make your work accessible to adjacent disciplines? How can you codify what you know into a framework that applies to cousins of your areas of interest?

    Honestly, the last thing we need are the 24-year olds who discovered no-code during the pandemic to teach people how to build no-code products. They don’t have the background to do it well.

    → 12:18 PM, Mar 1
  • Teaching reflections #9: Cross-discipline sharing is where it's at

    I was speaking with an English professor the other day. She was discussing how online teaching has changed her approach to class.

    Previously, she’d have individual conversations with students about improving their writing. Now she has those conversations publicly, with all students in attendance on Zoom. She was particularly concerned about constructive critique and not embarrassing students.

    I said, “Sounds like a music master class. Only you’re doing it with writing.”

    In a music master class, a form that has been part of classical music teaching for centuries, a well-known and well-respected audience teaches a lesson from the stage. There are a handful of performers, playing a piece they’ve worked on for some time. The artist works with the student for a period of time, often 15-20 minutes. Typically, the artist focuses on one aspect of the student’s playing; often it’s the artistry that gets attention rather than the mechanics of notes and rhythms.

    The audience gets enormous benefit from this:

    • They learn how a master performer thinks about and approaches a given piece of music.

    • They see teaching techniques on display, including how the student responds and improves to suggestions.

    • The audience may take some of the lessons back to their own playing in a moment of transferance.

    • The audience also listens critically, comparing their own performance of the same piece to the student’s and the artist’s work. Is there anything the audience member might take to improve their own work?

    • The audience also gets moments of critical thinking – do they agree with the artist’s analysis of the student? Many critiques are art, so there is no “correct” answer.

    In an academic environment, the English department would rarely (never?) overlap with the music department. Indeed, academics who attempt to be “cross-discipline” often are penalized in promotions and tenure decisions. However, her husband is a musician, and she understood the parallel to the master class having attended a few with him.

    Imagine how English class might change if they took more teaching tips from the music department.

    → 11:50 AM, Mar 1
  • Humanistic elements in education

    Below is a recent thread about what makes a good online course. Click through to read the whole thing.

    In the last 2 years, I’ve gone through 8 online courses but completed only two: WoP by @David_perell and BASB by @fortelabs. What makes them different and what can other course creators learn? Here are 11 components for creating a next-level online learning experience:

    — Julia Saxena 🚀🚢 (@julia_saxena) August 8, 2020

    Main points the author hits include:

    • Measurement of progress

    • Collaborative learning and feedback

    • Proper use of technology (like breakout rooms)

    But her first item was this:

    1. Onboarding: Before the course starts, let students reflect on their intention and goals. Measure their current state to show them where they are now. Then measure again at the end to show progress.

    — Julia Saxena 🚀🚢 (@julia_saxena) August 8, 2020

    This is the definition of [humanistic learning theory] (https://www.wgu.edu/blog/what-humanistic-learning-theory-education2007.html). The learner should have their own goals and [grades are irrelevant] (https://facultyweb.cortland.edu/andersmd/HUMAN/PRINC.HTML). Measuring their own learning is important.

    This can be implemented by giving the same quiz at the beginning and end of the course, so students can measure learning in a firm way. Or it can be mushier – asking students to reflect on what they’ve learned is one way of doing this.

    → 3:59 PM, Feb 19
  • Teaching Reflections #8: Good coding instructors are rare. Here's why.

    One of the great outcomes of studying instructional design from a theoretical perspective is the ability to spot patterns in teaching.

    When teaching software and coding, one typically encounters two theories in use.

    • Behaviorism : Just teach people the behavior and reward them for doing it correctly. Based on B.F. Skinner and others.

    • Best use is for the fundamentals of the subject. In math, it’s basic arithmetic. In languages, it’s alphabet, spelling, and grammar. In music, it’s notes, rhythms, and scales. If the teacher says “you just have to memorize this,” that’s behaviorism.

    • If you’re evaluating performance, it’s often done through multiple choice, true/false, and other means of regurgitating facts. Students are rewarded for memorizing, not applying.

    • If you were making a recipe, you would be rewarded for following all of the instructions correctly, rather than how good the recipe tastes. Behaviorism does not work in all kinds of learning.

    • Constructivism : “Learn by doing.” Base your learning on previous experience in the world, and apply that previous learning to the problem at hand.

    • If you’re following a recipe, you’re the person who changes the ingredients the first time you try it. You know what you like and what works from previous cooking experiences. You know you don’t like mushrooms, and you’ll leave them out of this recipe. You substitute butter for margarine, chicken broth for beef broth, and add meat to vegetarian dishes.

    • Best use is “doing” subjects once the fundamentals are mastered. Once a music student has learned a piece of music by a Baroque-era composer, how would the student apply those techniques and styles to the next Baroque-era piece she learns?

    • Evaluation happens through some kind of final product, not through the work along the way. Typically this is a project-based evaluation: a final research paper, a piece of working software, a film, a performance.

    • Constructivism shouldn’t be applied where there are absolutely right and wrong answers. It’s more about the shades of grey than the extremes of the spectrum.

    In the software and coding world, behaviorism drives most instruction one encounters. It’s the “help files” associated with the software: go here, click this, type that, and you’re done. In code, it’s dominated by StackOverflow and developer blogs: here’s a chunk of code that does this thing.

    Often, a coding class will start with examination of that chunk of code and some of its nuances. In that moment, students would tell you that they understood that code and its use.

    The next thing students are instructed to do is constructivist. “OK, now apply this to your own project.” No further guidance is given in that moment.

    This critical moment is the time when students decide they are not “good” at programming or technology. Instead, these students are a victim of poor teaching.

    The instruction isn’t necessarily bad. The instructor explained that code in minute detail. The idea of applying that code to your own project isn’t bad either. Unfortunately, there’s a step missing in between.

    That step is [transference] (https://learningsolutionsmag.com/articles/288/can-they-do-it-in-the-real-world-designing-for-transfer-of-learning). This is the moment you take a concept you learned in one context and apply it to the next problem. It’s really, really hard to do.

    Most people experienced this in grade school in math class. You memorized basic arithmetic all day long. You knew those times tables! But then… there were word problems. Word problems required you to read a few sentences, identify the problem that needed to be solved, identify the math to solve it, and calculate the answer. Most students did fine with basic arithmetic and failed miserably with word problems.

    Professional software engineers are very good at transference. Instructors are really good at it too. However, the majority of students need help in making the leap from one context to the other.

    [There are techniques that assist with transference] (https://learnnocode.dev/2020/12/27/the-fundamental-formula.html). Starting with a detailed explanation and ending with “try it yourself” are not fundamentally bad ideas. However, there’s much more in-between that needs to happen for an effective outcome for most learners.

    → 12:08 PM, Feb 12
  • Teaching reflections #7: Helping students choose engaging projects

    A capstone project should be balanced like the quintessential American meal: meaty main course, starchy side dish, vegetable side dish, and dessert.

    A good capstone project is constructed in a similar way. Let’s take the case of a website as a capstone project:

    • Meaty main course: The main focus of the capstone. It’s the website, the vehicle where all of the component parts are assembled. Usually students are focused on website coding and construction in this phase. In the case of a website, there’s many areas of focus here. Students may be working with a CMS plus custom theming, coding and integrating a CMS plugin, creating a single page web application, or building a browser extension.

    • Starchy side dish: This is where the student might have a complimentary secondary interest. In the case of a website, this might be a user experience (UX) focus; website planning, card sorts, flow charts, wireframing, and user testing are some of my favorites to discuss with students. If the student has a programming focus, this might include website performance improvements, server configuration issues, database design, and so forth.

    • Vegetable side dish: This is the deliverable area that feels like real work to the student, but it’s an area where they should grow. For programmers, it might be graphic or interface design. For graphic designers, it might be light programming. Writing quality content and storytelling is always a good addition for any type of web design student. Some of these deliverables may feel like a bit of a stretch to the student. A little stretch means growth. (Too much stretch leads to breakage, though, so watch for this as well.)

    • Dessert: There should always be a fun component to capstone, to keep students engaged, interested, and enjoying the process. These deliverables may be weighted minimally. They may also be outside of the main focus of the capstone. In the web design project, this might be some photography for the site, a social media promotion plan, or a short (1 minute) video clip or animation. Programmers sometimes want to try a new library or framework that they’ve wanted to explore but have never had the time.

    Combined with [students choosing a good project ] (https://learnnocode.dev/2021/02/06/teaching-reflections-identifying.html), this balance of deliverables should keep students engaged through the term.

    → 10:49 AM, Feb 8
  • Teaching reflections #6: Grading rubrics and capstone

    Capstone projects are all unique. Harvard’s digital media capstone projects are all over the map: films, courses, websites, UX projects, and combinations of these.

    It is impossible to structure grading for a capstone project for this reason. However, structured grading is most vital for this course among all others.

    In every other university course, grading happens during the term in some way through periodic assignments. Even in courses with a heavy assignment at end of the course, students still have some concept of how they’re doing as they complete their final work.

    However, a capstone should be evaluated as a complete work, rather than evaluated piecemeal through the term. While students should get feedback along the way, they shouldn’t receive a hard grade until the end. They should have the opportunity to refine all deliverables and aspects of the project in light of whatever they’re currently creating. The point of capstone is to bring together multiple aspects of the degree program and synthesize learning over the curriculum. Grading, therefore, needs to be at the end and encompass the full project.

    This clearly leads to potential issues. What happens when the student thinks they’ve done A work, but the instructor thinks it’s a C-? What happens when the student’s project isn’t “weighty” enough for a capstone? These potential surprises (risks!) must be mitigated in some way.

    As I’ve mentioned in a previous post, students don’t understand mitigating risk going into capstone, nor do they understand how to scope a project. We also have an issue of how to grade a unique project.

    Fortunately, a student-written grading rubric solves all of these issues.

    I review their rubric and make sure the bar isn’t set low or that they’re working on trivial things. But have faith in these adult students. They chose to go to grad school with a reason in mind. Most want to do well on their project, but they also want to learn something new and be proud of their work. With guidance, they write a challenging rubric that stretches them, but not too far so it’s still achievable within the semester timeline.

    Let’s go through all of the learning that happens when students write their own grading rubrics.

    The story of my capstone never follows the path I thought it would.

    Rubrics identify deliverables and completion timelines

    It’s one thing to say “I’m creating a 15-minute documentary on X topic.” It’s another to spell out exactly what it takes to create that: storyboarding, running the interviews, choosing the B-roll and music, editing it together.

    Larger deliverables may be broken down further. For example, an interview segment might be graded according to lighting, camera angle and focus, sound quality, color correction, how it furthers the story, and consistency of these characteristics across interview segments.

    Most students also put together a timeline for their work along with this list. I encourage them to create milestones, so they can quickly measure if they’re on track, behind, or ahead of schedule.

    When students write down all of the elements and stages they must complete to create their project, and particularly once they schedule these over the semester, they start to get a sense of scope. They realize whether they’ve committed to too much work and need to scale it.

    Rubrics determine how work should be weighted and graded

    Once students have completed their list of deliverables, the next question is how to grade each deliverable.

    There are two parts to this question. First, how do we evaluate each deliverable? Second, not all deliverables are created equal, so where should we place grading emphasis, and what should be minimized?

    Grading

    My students and I have conversations about how to communicate grading so that we’re both on the same page. How do you define good quality in a rubric so it’s clear enough to hang your grade on it?

    Still, my favorite rubric item shows up over and over, year after year: “The website will be simple and easy to use."

    A noble goal! But how do we measure that? What is simple and easy for you may not be for me. This is usually where I ask the student if they will do user testing to ensure the site is simple and easy to use. And if the testers show that it’s not, what will they do then? (Usually this is sufficent to convince them to refine this criterion in some way to reflect the intent, but in a more measurable way.)

    Students struggle with quality metrics in rubrics, but in the end, it’s a good exercise. It’s part of learning clear communication. It’s also useful for the end of the course, when they’re running out of time and they’re paralyzed by whether something is “good enough.” Since they made the decision of how to measure their work up front, allocating their time is an easier decision.

    Weighting

    Some deliverables are more important than others. Some should be completed at a different level than others.

    If a student is creating a documentary as their main focus, and they want to also complete a website for that documentary, I think that’s great. But the website is a minor deliverable. It might be built with Squarespace or other no-code technology.

    If a student is creating a website as their main focus, however, it’s not going to be built in Squarespace, and it will involve some level of coding.

    Within a deliverable, elements may be weighted differently as well. With websites, for example, some students want to emphasize graphic design, or page performance, or writing some type of code, or usability. All of these are important to the site, but not all need to be emphasized in the capstone project with a limited timeline. An ugly website with innovative coding may be as legitimate a project as a website with breathtaking graphics and photos and less coding.

    Students should have some say in what they consider important (and presumably where they want to spend their time), vs. what they consider less important. I ask students to reflect on their learning goals for this project, in addition to the amount of time required for each deliverable. Those that take more time might be worth more points. There may be some “stretch deliverables” that the student isn’t confident they can reach, but they don’t want to jeopardize their grade or graduation. These might be weighted less to help mitigate risk.

    Likewise, when students identify trivial deliverables (“navigation will work on all pages of the website”), I gently point out if they have not mastered navigation bars prior to enrolling in capstone, they are not qualified to build a website as a capstone project.

    Rubrics for time management

    In the last 4 weeks of the semester, as the students are in their final grind to complete their projects, inevitably some level of panic sets in. Some deliverables took longer than expected. Work was demanding. Home life is demanding, particularly in pandemic times. Life happened along the way.

    I remember when one student discovered a new technique for coding his project in these final weeks. He asked if he needed to refactor his project to use the technique. I asked what was on his rubric. Since neither the technique nor refactoring was listed as a deliverable, he understood he should keep going with what he had. Refactoring could be done after capstone.

    Other students are short on time but long on deliverables towards the end. I advise working on deliverables with heavier weighting. They can also decide what’s faster and easier to complete and concentrate efforts there.

    Rubrics for organizing deliverables

    “Here’s my film!” Great! Now what?

    I have students use their rubric as an organization tool for their deliverables. Where should I look for proof of excellence in each criterion?

    Not all deliverables are contained within the main project (film, website, course). For example, a storyboard is critical to the film, but it’s a separate deliverable from the film. Many website and course deliverables also follow this pattern.

    Rather than being forced to hunt for All The Things, students choose where I look. Time stamps, website addresses, lines of code, Word documents, and more form the basis of deliverables.

    Rubrics for reflection

    Finally, students fill out their own grading rubric as part of the reflection process. (I also ask them to write a final blog post reflecting on what went well and what they’d do differently next time.)

    When students grade themselves, they are required to compare their work with the measurements they set. Did they achieve these metrics? Why or why not?

    In most instances, students gave themselves lower marks than I did, sometimes dramatically so. The rest of the time, I agreed with their assessment. I can only think of one instance where my grade was lower than the student’s.

    Many students start this grading and reflection exercise with an eye roll, believing it’s the final busy-work hurdle to graduation. But I don’t give busy work. By the time they’re done, they usually comment on how useful the reflection process was.

    Whew, that’s a lot for one grading rubric. If you wind up with capstone students, I strongly recommend trying it with your next cohort.

    → 1:37 PM, Feb 7
  • Teaching reflections #5: Identifying projects in capstone

    Master’s degree programs generally have one of two endings. Either students write a thesis, or they complete a capstone project. Where students want to further job prospects in technology, rather than an academic or research-based career, a capstone is a much better choice. Students get to complete a large, meaty project that brings together many aspects of the degree program.

    Capstone is also a good time to teach how to choose a great project.

    The timeline for capstone is usually 7-9 months and is generally completed in three phases.

    • In Phase 1, students are asked to identify a project they’d like to work on. This is typically an informal exploration, plus discussions with capstone instructors and advisors.

    • In Phase 2, they write a capstone proposal. This is often a semester-long process, and it may be combined with Phase 1.

    • In Phase 3, they implement their capstone proposal, usually over a semester.

    Each of these should be a post, so here I’ll start with Phase 1, identifying a project.

    When I did my own capstone project in grad school, I already had a vision of what I wanted to accomplish. I was in grad school to train to become a web designer. (It was 2000. Different times.) I wanted a project that paid me to do the work. I wanted a well-known name brand to work with, ideally, rather than a small local business. I wanted to build the website from nothing – I wanted the experience of gathering requirements and goals, creating site maps from a card sort, doing the graphic design, and coding the whole thing inside of Dreamweaver (as one did in those days). I wound up doing a website for Massachusetts 4-H, which was housed at UMass Extension. This project lead to many others through UMass over the years.

    Naturally, I thought other students would have the same experience. Not true!

    I found that students were unable to think about the capstone project beyond “what can I do to get an A, graduate, and move on.” I started asking the students these following questions to help structure their thinking.

    • Why did you go to grad school in the first place?

    • What kind of job do you want when you graduate?

    • What is missing between that job you want and what you’ve learned here? What did you want to learn more about? What skills do you want to demonstrate?

    • Is there life for this project beyond capstone? It’s a lot of work, so if we can use capstone to launch a business, get a job, or some other way launch your future life, this is worth exploring.

    • What would hold your interest for 7-9 months of intense work?

    Through the years, I’ve realized this type of structured thinking is missing in many aspects of student work. It’s lead me to incorporate more structure in assignments to better guide students to what I’m looking for in projects. Thus my famous “turn-in sheet” was born. And that is another topic for another post.

    → 10:59 AM, Feb 6
  • Teaching reflections #4: Teaching risk in capstone projects

    After 20 years of teaching in academia, I’ve coached many capstone projects.

    Part of the capstone process is examining risk and mitigating it. Students have very little ability to do this, even after completing courses and assignments for a full degree program. This is because in a regular course, the instructor assigns all materials to consume and study and provides assignment(s) that have deadlines. Students manage time and scope based on work that’s already defined these parameters for them.

    That means that when a student is creating a project of their own, they do not understand how to properly scope their work within the time parameters.

    They also don’t understand risk. In a standard university course, risk during the semester usually looks like this for adult students with jobs and lives:

    • High probability, low impact: Work or kids get demanding during a portion of the course. Work ahead, talk to the instructor, and usually you get through this without significant damage to the grade.

    • Low probability, low impact: Not completing a weekly requirement: not attending class, not completing a weekly quiz, not posting a discussion post. This could be simply forgetting something, or it could be a conflict with other parts of life meant that the work just didn’t get done.

    • Low probability, high impact: Death in the family, severe illness of the student or in the student’s family, childbirth during the term. Universities have methods of working around these issues via course incompletes. Students should always talk to instructors to get help when these issues happen.

    • High probability, high impact: There are certain students who are consistently bad at managing time and always seem to have some drama going on. If you talk to other instructors who had this student previously, you’ll discover the pattern across all courses. However, these students are rare in adult learning programs.

    In other words, while students are always concerned about getting a lower grade than they think is reasonable for their work, talking to the instructor consistently and being engaged in the course is generally enough to get through it.

    For a capstone project, they are concerned about failing the project and jeopardizing graduation. Low probability, high impact. However, when the student controls most of the project, as is true for most parameters of capstone, the probability is higher here than it is for other courses. Students don’t understand how to scope their work – a topic for another post – and can easily sign up for too much to complete within the allotted time. This is the biggest reason that capstones would not be completed.

    How to mitigate this risk? Focus on what’s needed for the project to get to graduation.

    Consider the metaphor of visiting an all-you-can-eat buffet the first time. It’s amazing! There’s so much food! You can eat whatever you want and they bring more! But pretty soon you’ve tried a few things, and you’re getting full. You didn’t get to dessert yet because you ate too many dinner rolls.

    Students in a healthy relationship with their capstone project have similar issues. They want to do ALL THE THINGS and make an amazing project. They identify more things along the way that they want to do. All the while, the clock is counting down. While the student may believe all of the things are required to make a good project for a portfolio, it’s unlikely that they’re all required to complete capstone satisfactorily and graduate.

    (Students in an unhealthy relationship with their capstone project do the absolute minimum. It’s rare, but it does happen occasionally. Usually this is affected by outside forces – illness, death, other life issues. The student may also have chosen a poor project that isn’t engaging for them. That’s for another post.)

    As an instructor, you must teach them about the low probability, high impact problem of not doing the right things for graduation. Graduation is always goal #1. Everything else is Phase 2.

    One of the ways I’ve kept students on track to completing their capstones is through a grading rubric. This is also suited to another post, but briefly, a rubric identifies what they will do, how important that work is, and how it should be graded. It’s a contract of sorts.

    Future posts:

    • The power of the student-written grading rubric in capstone

    • Scoping capstone projects and keeping students in scope

    • Helping students choose engaging capstone projects

    → 10:21 AM, Feb 5
  • Teaching reflections #3: Making mistakes when teaching

    Mistakes happen. I’ve certainly made my share.

    However, instructors FREAK OUT when they make mistakes when teaching. They mistype something, misconfigure some setting, make syntax errors, and so forth.

    Then they edit the video, completely concerned that they look stupid.

    Through the years, my students taught me that my mistakes were a powerful moment for them.

    First: OMG the instructor makes that SAME MISTAKE that I do all the time! Wow!!! (There’s power in seeing yourself in a role model.)

    Second: When I make a mistake, I don’t FREAK OUT. I look at the problem and try to figure it out. I ask the class what I did wrong. I model how to debug an error. This is important. Students are going to make errors too. Do they know how to debug?

    Finally: Even when I’m on video and I make a mistake, I don’t edit out the problem in my own videos. (For commercial video, this is another matter, of course.) Again, students should know that errors happen to everyone and tracking down the problem is part of programming.

    Indeed, that’s the biggest takeaway: Everyone makes mistakes, so why can’t you? It’s part of programming and learning.

    → 4:50 PM, Feb 4
  • Teaching Reflections #2: Taking risks in assignments and learning

    Next time you're afraid to share your ideas, remember someone once said in a meeting, Let's make a film with a tornado full of sharks.

    Next time you’re afraid to share your ideas, remember someone once said in a meeting, “Let’s make a film with a tornado full of sharks."

    Students are always afraid to think creatively about their work. In academia, they’re worried about their grade, which drives much of this fear.

    However, taking risks is where student learning is greatest. Trying something and having it fail is one of the greatest experiences for a student, when handled correctly.

    This is why reflection is so important for students.

    At first, it feels like busy work. Why do I need to reflect on the work I did? I know what went right or wrong. I know what to do next time.

    However, when they must organize those thoughts into a coherent paper, video, or presentation, they learn much more about what happened.

    It’s not just the project failed. Now it failed because I did X, so Y happened, and Z was the outcome. Next time, I’ll do A because B. I expect that to help because C.

    Look at all of the “because” in that paragraph. Because is the hard part. It’s easy to say something didn’t work. It’s really hard to articulate why and how to avoid that outcome in the future.

    → 9:46 AM, Feb 4
  • Teaching reflections: Introduction

    I’ve taught for 20 years in academia.

    I’ve been a teaching assistant, an adjunct instructor, a lecturer with benefits, and a program director.

    I’ve taught courses with syllabi developed by others. I’ve developed my own syllabi for courses with objectives and nothing else. I’ve identified and created my own courses from nothing to fit inside of a degree program. I’ve created the entire degree program.

    I’ve mentored maybe 200 students over the course of this time through some type of capstone or thesis project. These are the big projects that students create at the end of their degree program that synthesize everything they’ve learned into a portfolio-worthy project. Most of my mentees were graduate students.

    Some of those students had a clear vision of what they wanted in life. Others went to grad school to “learn more about computers.”

    When it came time for capstone, everything changed. The style of teaching, the expectations of students and instructors, the work, the overwhelm, the self-doubt, and the joy of completion were always part of the journey.

    Over the next several posts, I will identify a few common themes that ran through nearly every capston project I advised. We’ll start here, with one of my favorite capstone cartoons. Every student experienced this somewhere along the way.

    → 9:41 AM, Feb 4
  • RSS
  • JSON Feed
  • Micro.blog