I've been much more on top of my beekeeping chores this year than I was last year. This year's colonies are three wild swarms caught in the area (one from a friend who ran out of room, and two from my own property) and that generally means slower growth as they re-establish themselves in a new location.

Of the three, two were doing great. The brood patterns have been strong and the bees are foraging like mad. One even has two honey boxes on top because they were working so well after I put them into their permanent box. The third colony was a little slower than the others...they had a ton of nectar and pollen stored, but I wasn't seeing much brood.

Sometimes, when a swarm is relocated, the queen can be slow to start laying, so I didn't worry too much. This week, though, there was definitely serious trouble.

Queens lay fertilized eggs, which become female workers. Unfertilized eggs become male drones who are only around to mate with queens. They're big, fat, and don't contribute to the health of the hive. Dones are around to help diversify genes and not much else. There are always some drones around, but when I opened the hive this week, all I saw were drone cells, which is not a good sign.

Either I had a virgin queen who failed to mate (no fertilized eggs) or I had lost the queen somehow and the hive failed to raise a new one. In that situation, the last-ditch survival instinct of the colony is to have workers lay eggs. The problem is that these eggs are unfertilized, so all they produce is drones. A colony in this state will not survive.

The University of Guelph in Ontario, Canada, has a fantastic honey bee research center which produces videos on just about everything you would ever want to know. Sure enough, they have a video on how to handle laying worker hives.

I went to work and combined the dying colony with the second hive. It wasn't as close to the original location, so there was a little bit of a traffic jam as forages came back, so I threw an entrance reducer in place to help that colony manage the influx of bees.

Now that the dying colony has been united with a queenright colony, the pheremones of the living queen and her brood should shut down the laying workers and all should go back to normal. I'm in southwest Michigan, so I won't split them back out this year - they'll go into winter as a double brood setup, but I'll be able to do a split when the spring comes around and be ready to go next season.

Coming off my recent post on my changing goals ten years into my degree, now I want to take a look forward and set some learning goals for the coming years.

The last several years of my work have been with adults rather than students and has included significant time at the leadership level. Working as a conduit for leadership to the classroom, I've learned a lot about how to translate broad goal statements into actionable practices with students. At the same time, I've felt a growing tension in my own work because I don't have my own classroom in which to put the methods I'm teaching to work.

With that in mind, there are three areas in particular in which I would like to grow as a classroom teacher and as a teacher-leader: inclusive teaching practices, assessment and reporting, and systems for efficacy.

Inclusive teaching practices

"All means all" is a phrase our team uses to make sure we keep every student in mind as we prepare, execute, and reflect on instruction. Universal Design for Learning is a helpful framework for ensuring that instruction is accessible for all students from the way we prepare materials to our instruction in the classroom. My first goal is to use the Center for Applied Special Technology (CAST) framework for Universal Design when I'm preparing course materials. In particular, I'm going to focus on the representation domain.

I'm a science teacher by training, so much of my early work was focused on clear explanations of ideas with graphics to help students build mental models of abstract ideas. However, this is a limited mode of representation of ideas and may not be accessible for students, particularly those who speak limited English or struggle with auditory processing. By reflecting critically on ways in which I represent scientific ideas, I'm hoping my classroom instruction becomes more effective for more students.

In addition to content representation, I want to learn more about how to exhibit explicitly anti-racist teaching practices, particularly those described by Dr. Bettina Love. This is an area that will definitely strech me as I reconcile my implicit privilege and ways in which I make my classroom welcoming to all students.

Assessment and reporting

Flowing from making instruction more accessible by all students, I'm interested in developing more effective modes of assessment and ways in which we can report student progress. I've used standards-based (or standards-aligned) assessment and reporting for a long time and there is room for growth in how I collect data, provide feedback on learning targets, and then support students in their continued improvement. As I consider teaching in the classroom, I want to develop clear systems for students to track their own growth and improve communication between myself and parents as we work together to support their student.

Beyond the classroom, I'm interested in how schools as a whole can use agency over grade reporting to give an accurate - and holistic - view of education based on assessment. Beyond content skills reported in the classroom, what goals or skills does the school want to see students develop? How do we report that progress or support students in skill development? A very interesting project I came across recently is the Mastery Transcript Consortium which helps schools re-envision how they communicate student learning and that may be a good place to get some starter ideas.

Systems for efficacy

A good friend of mine is a doctor and he frequently laments the amount of time he spends in front of a computer. A majority of his interaction with patient care is following a quick check with the individual when he's reading lab results, interpreting the data, and then ordering next steps. The digitizing of processes has made the system more efficient at order and reporting tests but has made him feel less effective as a caregiver.

The education technology boom of the late aughts and early 10's has led to a similar situation - teachers and schools have more webistes, apps, and resources to track students but at the cost of engaged learning. We have put time and effort into systems that make us more efficient at measuring but, I would argue, less effective at creating lifelong learners.

I don't feel this goal is in conflict with the previous section, but rather a companion. I want to explore effective teaching strategies as paired with timely, actionable, and insightful moments of assessment which help students grow. In what ways can I structure my classroom so students can explore ideas as well as demonstrate their own understanding without falling into an endless series of assessments? Professional Learning Communities (PLC) are a structure which help teachers define curriculum and assessment collaboratively, which can help with some of this growth I'd like to achieve.

A unified approach

Each of these learning goals supports the other - an inclusive, accessible classroom provides students a safe space to engage with and explore new ideas. Assessing students for learning in ways which provide actionable feedback will be a main method of growth support. Using tools critically and responsibly will allow me to communicate critical information in a way which drives next steps. Removing any one area of growth will hinder another and I think the biggest challenge our of each of these three is finding the right balance.

I needed an unplugged activity to bring some non-technical creative balance to my life. I decided that sketching and watercolors were what I wanted to stretch myself with and I share pictures a lot of my Fosstodon account, but I don't post them here often.

Well, dear reader, today is your lucky day.

Clouds are hard to paint, as evidenced by one of my first attempts:

I've watched some videos and have done a couple more small attempts at clouds, particularly this seek when the high temperatures and super high humididity have created some impressive towers.

This week, I tried to capture a major storm a few miles north of the house:

I'm still not great at mixing color and using water to create the soft subtle edges on the clouds. I was frustrated with the muddiness of the painting on the left, so I came back inside and did the one on the right, which I'm much happier with.

I realized that much of what I'm trying to do is unnecessary - I'm trying to fill up too much space when what I need is to leave more untouched space and really only paint in the accents. The eye fills in the detail and I don't take advantage of that fact enough.

I've written about this on the work blog before, but never here. We're doing some course cleanup prepping for the fall and, at the same time, I'm finishing a graduate course on online learning, which is making me think much more deeply about how we build and implement courses for staff.

This week, we explored Michelle Pacansky-Brock's research into "humanizing" online education, in particular because of the spectrum of online learning that was done during (and post-) COVID. Online learning was around before COVID put a lot of people into the space for the first time, but the interest in how to make online learning more engaging and more relational has increased.

Most of our PD courses are hybrid - staff see a coach several times while completing a program - but there is a large portion we house in Canvas. We rely on the LMS to hold information organized into topics or ideas that participants explore over a period of time.

In each module, a participant has to submit evidence of application. In the past, this would trigger a visit with a coach to discuss their submission. But, what if this was a fully online program with no coach visit? How can we give participants timely, actionable feedback on their instruction without actually visiting their classroom?

I decided to focus on her concept of "warm, wise feedback" by adding some single-point rubrics to each of our evidence submission items to guide our participants' thinking and provde feedback which can humanize the online course.

The idea of a single-point rubric is simple: students receive feedback on what they did well to show their understanding or what they need to improve in order to demonstrate growth. The rubric does not have points attached - just a comment box. It provides a way for the coach to give targeted feedback on the core components of the task. The participant has a mental model for the kind of work they should exhibit by completing the task and they know they'll receive feedback on key components of the skill being explored.

Attaching these rubrics to the evidence submission page communicates what the participant should be able to do as a result of completing the module. Including the rubric gives them a chance to reflect on their work and pick the best evidence for the skill to share with the coach. The coach is then equipped to work with the teacher in specific, targeted ways to continue to improve.

I don't love that Canvas (or any LMS) still uses "judgy" language in the rubric - "Ratings" instead of "Feedback" - but by removing points or other indicators of "passing" or "failing," we're able to focus on the process of improvement.

While this is geared for adult learners, the same can easily be done for students. On your content standards, consider adding places for students to creatively demonstrate understanding, maybe with a choice board or open-ended response items. Using single-point rubrics to humanize the learning space reinforces that learning is a process and we go through the process together.

Resources

Gonzalez, J. (2015, Feb. 4). Meet the single point rubric. Cult of Pedagogy. https://www.cultofpedagogy.com/single-point-rubric/.

Pacansky-Brock, M. (2020). How to humanize your online class, version 2.0 [Infographic]. https://brocansky.com/humanizing/infographic2

I've been using HTMX for a couple years now and I'm still loving the patterns and interaciton it allows without relying on writing Javascript for everything. The developer experience is great and I can just write HTML and CSS templates to make everything work nicely.

HTMX works by sending AJAX requests and then dynamically inserting the responses into your page so it feels like a SPA without relying on weird Javascript syntax to make it all work. The server handles all of the requests and spits out HTML (which is the way things should work).

There are two other libraries I use to make things easier in development:

• The Flask-HTMX library makes it super easy to check if something is an AJAX request from HTMX or if it's a browser action.
• Jinja Partials by Michael Kennedy allows you to reuse small blocks of HTML, almost like a component library.

The problem that comes up has to do with browser refreshes - since most routes return partial HTML, a browser refresh on a particular route will return unstyled HTML. That's bad.

In order to prevent this, I came up with the following pattern:

example_template

```html

```

flask route ```python @app.route('/example') def example(): template = "example_template.html" resp_data = { "id": 1, "name": Example 1, "text": "This is some string text to render." }

# Flask-HTMX creates a property on the request object if an HX-* header is present.
# If it is present, render the partial template directly and let HTMX insert it into the DOM.
if request.htmx:
    resp = render_template(template, **resp_data)
else:
    # If it is not present, render the partial template in a full-page wrapper to include all CSS and script tags again
    resp = render_template(
        "shared/layout_wrapper.html",
        partial=template,
        data=resp_data
    )

return resp

```

If a request comes from HTMX, then return the template partial as expected. If it's not from HTMX - in other words, a browser action of some sort - then wrap the response in a template and return the wrapped response. Here's the wrapper:

layout_wrapper.html ```html {% extends '_layout.html' %} {% block main_content %}

{{ render_partial(partial, **data) }}

{% endblock %} ```

This all works well and good, but now it means that my routes all have the if...else... block as part of the function. It's super repetitive and I felt like there had to be a better way.

Decorators

Since the response needs to be modified before rendering, flask.after_request() wouldn't work because there response already has the built HTML string. This solution uses a decorator to modify the response before returning the function results.

The Flask docs actually include a templating decorator example that got me most of the way there. Now, instead of using an if...else... inside the view, I can wrap any refreshable route with a decorator which will then return the appropriate response:

wrapper.py ```python from functools import wraps from flask import request, render_template

def templated(template=None): def decorator(f): @wraps(f) def decorated_function(args, kwargs): template_name = template # Catch the data returned by the view ctx = f(args, kwargs) if request.htmx: resp = render_template(template_name, ctx) else: resp = render_template( "shared/layout_wrap.html", partial=template_name, data=ctx ) return resp return decorated_function return decorator ```

flask route ```python from wrappers import templated

@app.route('/example') @templated(template="example_template.html") def example(): resp_data = { "id": 1, "name": Example 1, "text": "This is some string text to render." }

return resp_data

```

Each route shrinks significantly. The added benefit is that the returned template is defined right at the top of the route and isn't dependent - in this view - on where the request came from, the right one is returned either way.

It's a small change, but the reusability of the decorator paired with the template patterns have made my code more consice and more readable in general. Plus, it's just cool to be able to make these quality of life improvements as I learn more.

I work a reduced schedule during the summer and one thing I constantly run into is not really knowing where to start when I come into work after several days off. It's often to a fullish inbox and several other items which need addressing. On top of that are the long-term projects and tasks which need some attention during the summer months.

The problem is I don't really want to wade through several dozen emails (ok, not always dozens, but they do pile up) or dive right into a project. It takes me a little warmup time to really feel like I can get into a flow at work, particularly when my working days are spaced out irregularly.

My best trick is to keep some no-thought tasks on my todo list. These are things like filling out my time sheets for the previous week's work or signing off on reimbursement receipts. They are tasks which just need to get done and take very little effort other than opening up the calendar or the expenses spreadsheet.

Once I do those things, my blood is flowing a little more freely and I'm able to put more mental energy into other tasks.

On a side note, I'm a fan of the Getting Things Done mentality for task management. There's a great CLI tool - todo.txt-cli which keeps a standard-formatted text file for tasks and completed projects. On top of that, I use a TUI called pter to interact with the tasks. The todo.txt-cli has great tools and a plugin system for creating extensions, but pter is super well-built, offers intuitive tooling, and has great documentation. I generally have a terminal window open with pter running and then I'll hop into the CLI to run some stats every now and then. Give those a try if you're looking for a lightweight, customizable todo system.

I happened to see a post about bleach, a text input santization library, deprecated in January. I have a couple of apps which use this library to strip out HTML tags which can be used to do mean things and I needed to make some updates.

Luckily, there's a new project, nh3 which made this super painless. It's a Python wrapper for a Rust library which performs the same task super easily.

I wasn't actually using bleach in my projects - I was using bleach_extras which allowed me to strip the content within the tags, not just the tags themselves. nh3 provides this out of the box. Here's what the original function looked like:

```python

import bleach_extras

string = "

This is a