Danke Hidayat

Automating Calibration and Report Generation with Google Colab

Fri, 17 Oct 2025 00:00:00 GMT

Comparing a low-cost sensor against a reference and writing up the result by hand is repetitive work. This note describes a workflow that does the whole thing inside Google Colab: extract paired readings from Google Sheets, calibrate the DHT11 against an HTC-1 reference, evaluate agreement with regression and Bland-Altman analysis, classify thermal comfort with a Mamdani fuzzy model, and generate a complete scientific-style report as a PDF, all from a single notebook.

Objective

Temperature and humidity matter in tropical workspaces, where natural ventilation carries most of the thermal load. Low-cost sensors such as the DHT11 are widely used, but their readings drift. The goal was to quantify the offset against an HTC-1, correct it with a data-driven calibration, and produce a report that could be regenerated whenever new data arrived.

Data Collection

The DHT11 and the HTC-1 sat side by side in a naturally ventilated office in Indonesia. Two datasets were recorded:

Before calibration, to establish the baseline error
After calibration, to verify the correction

Each dataset spanned several hours of normal office activity, so the comparison covered realistic changes in temperature and humidity rather than a single static condition.

Analysis in Colab

The notebook loads the paired readings from Google Sheets using gspread, then computes error metrics for the raw and the calibrated series. Mean absolute error and standard deviation summarize how far the DHT11 sits from the reference. A linear regression quantifies the relationship between the two sensors, and a Bland-Altman comparison checks bias and agreement across the measurement range instead of collapsing everything into one number.

The key metric is the mean absolute error:

$$ \mathrm{MAE} = \frac{1}{n}\sum_{i=1}^{n}\left|\hat{y}_i - y_i\right| $$

Calibration Results

After calibration, the DHT11 tracked the reference much more closely. The mean error and its spread both shrank, and the fitted regression line moved toward the line of identity. For a low-cost sensor, the improvement was substantial enough to make the readings usable for further analysis.

Fuzzy Mamdani Classification

Raw numbers are hard to interpret, so a Mamdani fuzzy model converted each reading into a thermal comfort category. Membership functions over temperature and humidity produced states from COLD through COMFORTABLE to HOT, which read naturally when compared with how the room actually felt.

The classified readings were then checked against the ASHRAE 55-2020 comfort range for naturally ventilated spaces in tropical climates, 23 to 28 degrees Celsius. The analysis reported the share of readings inside that band:

When less than 70% of readings were comfortable, it recommended specific actions: optimize natural ventilation during the hottest hours, add fans to improve air circulation, and review internal heat loads from equipment and lighting.
When at least 70% were comfortable, it recommended keeping the existing ventilation pattern and monitoring periodically to catch drift early.

Automated LaTeX Report

Once the analysis finished, the notebook assembled the report with pylatex: sections for the methodology and results, plus figures inserted directly from the analysis. The document compiled to a PDF and was saved to Google Drive so it could be shared immediately after each run.

from pylatex import Document, Section

doc = Document("Scientific_Thermal_Comfort_Report")

with doc.create(Section("Results and Discussion")):
    doc.append("This section presents the calibration outcomes and fuzzy logic analysis performed in Colab.")

doc.generate_pdf(clean_tex=False)

Why Automate

The notebook turned a one-off comparison into a repeatable pipeline. New data can be added to the sheet and the report regenerated in a single run, which makes it practical to re-validate the calibration as the sensors age or the environment changes. It also showed that an inexpensive sensor like the DHT11 becomes far more reliable once its readings are corrected against a proper reference.

Resources

GitHub Gist: DHT11 & HTC-1 Calibration Script https://gist.github.com/dankehidayat/1e7b296543a7aef27e711bea51d5cdd6
Generated PDF Report: https://drive.google.com/file/d/1Z6PtvuDW63F5cUrvonf1WnnZPhWKushy/view
Original Post: https://dankehidayat.my.id/blog/2025-10-17-automating-calibration-report-generation

Energy Monitoring System Calibration: Linear Regression Approach for Sensor Accuracy

Tue, 14 Oct 2025 00:00:00 GMT

An energy monitoring system is only as trustworthy as the data it collects. When the readings feed HVAC control, small sensor errors compound into real misallocation of energy. This note describes how the Eco Office monitor, an ESP32-based system, calibrates its DHT11 temperature and humidity sensors against a reference instrument using ordinary least squares regression, and how the fitted model is deployed directly in the firmware.

The DHT11 is inexpensive and easy to interface, but its accuracy is limited. Compared against a calibrated HTC-1 reference, the raw readings showed a mean absolute error of 3.84 degrees Celsius in temperature and 14.18% in relative humidity. Those offsets are too large for a system that uses environmental data to regulate cooling and heating.

Why Calibration Was Needed

Before calibration, the raw DHT11 readings diverged from the reference across the whole measurement range:

Temperature: mean absolute error around 3.84 degrees Celsius, with maximum errors approaching 5 degrees
Humidity: mean absolute error around 14.18%, with large spikes at the extremes
A consistent negative bias in temperature and a positive bias in humidity

Errors of this size would distort any downstream calculation, from thermal comfort classification to energy consumption analysis. The readings had to be corrected before they could be used.

Measurement Setup and Data Collection

The DHT11 and the HTC-1 were placed side by side in a naturally ventilated office in Indonesia and logged concurrently for about nine hours. Logging spanned warm and cool parts of the day so that the model would see realistic variation.

In total, 19 paired readings were collected. Temperature ranged from the mid-20s to the upper-20s degrees Celsius and relative humidity from around 46% to the low 70s. That spread is sufficient to fit a first-order model and to check how the correction behaves across the operating range.

Calibration Model

For each variable, a first-order model maps a raw reading $x$ onto a corrected value $\hat{y}$:

$$ \hat{y} = a x + b $$

where $a$ is the slope and $b$ is the intercept, fitted separately for temperature and humidity. The coefficients fitted from the paired data and later embedded in the firmware are:

$$ \begin{aligned} \hat{T} &= 0.923,T_{\text{raw}} - 1.618 \ \hat{H} &= 0.926,H_{\text{raw}} + 18.052 \end{aligned} $$

The quality of the correction is reported as the mean absolute error (MAE) against the reference:

$$ \mathrm{MAE} = \frac{1}{n}\sum_{i=1}^{n}\left|\hat{y}_i - y_i\right| $$

Model Deployment in Firmware

The firmware stores the four fitted coefficients as constants and applies them on every DHT11 read, so each measurement is corrected before it is used or published:

const float TEMP_SLOPE = 0.923;
const float TEMP_INTERCEPT = -1.618;
const float HUM_SLOPE = 0.926;
const float HUM_INTERCEPT = 18.052;

float calibrateTemperature(float rawTemp) { return (TEMP_SLOPE * rawTemp) + TEMP_INTERCEPT; }
float calibrateHumidity(float rawHum) { return (HUM_SLOPE * rawHum) + HUM_INTERCEPT; }

A multiply-add per reading is negligible on the ESP32, which is one of the reasons a linear model was chosen over a heavier approach.

The firmware also keeps a ring buffer of the last 10 per-sample errors and reports a running mean absolute error. That value is converted into an accuracy figure over the measurement range:

$$ \mathrm{accuracy} = \max\left(0,; 100 - \frac{\mathrm{MAE}}{\mathrm{range}} \times 100\right) $$

This gives the dashboard a single percentage that summarizes how close the calibrated readings are to the reference.

Results

After applying the fitted models, the error metrics improved substantially:

Temperature

Mean absolute error dropped from 3.84 degrees Celsius to 0.80 degrees Celsius
Maximum error dropped from roughly 5 degrees to about 1.4 degrees
The negative bias disappeared and the residuals scattered evenly around zero

Humidity

Mean absolute error dropped from 14.18% to 1.15%
Maximum error shrank to roughly 2%
Consistency across the range improved noticeably

Overall, temperature accuracy improved by about 80% and humidity accuracy by more than 90%. For a low-cost sensor, that brings the readings within a useful range for energy analysis.

The Analysis Code

The regression was fit with a small Python class. The coefficients below match the values deployed in the firmware:

import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, r2_score

class SensorCalibrator:
    def __init__(self):
        self.temp_model = LinearRegression()
        self.humidity_model = LinearRegression()

        # Coefficients from the regression analysis
        self.temp_coef = 0.923
        self.temp_intercept = -1.618
        self.humidity_coef = 0.926
        self.humidity_intercept = 18.052

    def calibrate_temperature(self, raw_temp):
        return self.temp_coef * raw_temp + self.temp_intercept

    def calibrate_humidity(self, raw_humidity):
        return self.humidity_coef * raw_humidity + self.humidity_intercept

    def evaluate_calibration(self, raw_readings, reference_readings):
        calibrated = [self.calibrate_temperature(t) for t in raw_readings]

        mae = mean_absolute_error(reference_readings, calibrated)
        r2 = r2_score(reference_readings, calibrated)

        return {
            'mae': mae,
            'r2': r2,
            'calibrated_readings': calibrated
        }

A quick example:

calibrator = SensorCalibrator()
raw_temp = 25.0
calibrated_temp = calibrator.calibrate_temperature(raw_temp)
print(f"Raw: {raw_temp} C -> Calibrated: {calibrated_temp:.2f} C")

Downstream Use in the System

Calibrated values feed several consumers inside the Eco Office monitor:

A fuzzy Mamdani engine classifies thermal comfort into COLD, COOL, COMFORTABLE, WARM, and HOT states from temperature and humidity.
A second fuzzy engine classifies energy consumption into ECONOMICAL, NORMAL, and WASTEFUL states using voltage, active power, power factor, and reactive power from the PZEM-004T.
MQTT telemetry publishes the corrected readings every 30 seconds to the Selene platform.
The on-device LCD and the Blynk widgets display the calibrated values and the fuzzy states.

The PZEM-004T measures voltage, current, active power, power factor, frequency, and cumulative energy. One unit note matters here: the library method PZEM004Tv30::energy() returns kilowatt-hours directly, while the underlying register is stored in watt-hours and divided by 1000. The MQTT field, the Blynk widget, and the LCD all use kWh consistently.

Final Thoughts

Linear regression turned out to be a simple and effective way to calibrate low-cost sensors:

It reduced temperature and humidity errors to a fraction of their original values
A multiply-add per reading is cheap enough for embedded hardware
The resulting coefficients are easy to inspect, test, and update in the firmware
Corrected readings made the downstream fuzzy classification and telemetry substantially more reliable

The next step is to explore non-linear calibration and automatic recalibration, particularly to handle sensor aging and slow changes in environmental conditions.

Japanese Input with Mozc + Fcitx5 on Arch Linux (Wayland + Hyprland)

Fri, 18 Apr 2025 00:00:00 GMT

Setting up Japanese input on Linux can feel a bit confusing at first, especially if you’re new to the ecosystem. When I first tried writing Japanese on Arch Linux, I bounced between different input managers and configurations before finding a setup that “just works.” So in this guide, I’ll walk you through how to get Mozc + Fcitx5 working smoothly on Arch Linux with Wayland (Hyprland) — the same setup I use daily.

While these steps are for Arch (and distros that use pacman, like EndeavourOS or Manjaro), you can still apply the general idea on other distributions. The only part that changes is the package manager:

Debian/Ubuntu: apt install fcitx5-mozc
Fedora: dnf install fcitx5-mozc
openSUSE: zypper install fcitx5-mozc

Everything else — configuration, environment variables, and Mozc settings — works similarly.

1. Install the Required Packages

Let’s start with the essentials. Install Fcitx5, Mozc, and the config tools:

sudo pacman -S fcitx5 fcitx5-configtool fcitx5-qt fcitx5-mozc-ut

This gives you the input manager (Fcitx5), the Japanese engine (Mozc), plus the UI tools to configure everything.

2. Set Up Environment Variables

Next, your system needs to know that Fcitx5 is the input method framework you’ll be using. Add these lines to your shell config (~/.zshrc, ~/.bashrc, or ~/.profile):

export GTK_IM_MODULE="fcitx"
export QT_IM_MODULE="fcitx"
export XMODIFIERS=@im=fcitx

Then apply the changes:

source ~/.zshrc   # or source ~/.bashrc / ~/.profile

A quick log-out and log-in will ensure everything loads properly.

3. Configure Fcitx5

Now that Fcitx5 is installed, it’s time to make Mozc your Japanese input method.

Open fcitx5-configtool.
Click + to add a new input method.
Uncheck “Only Show Current Language” so Japanese engines appear.
Search for Mozc and add it.
Remove any input methods you don’t want, like “Keyboard - English.”

At this point, Fcitx5 should appear in your system tray or panel.

4. Enable Japanese Input

Here’s the fun part — switching languages.

By default, you can toggle between English and Japanese using:

Ctrl + Space

Try typing nihongo and you should see:

にほんご

If that works, you’re officially ready to type Japanese anywhere on your system.

5. Optional: Install Themes for Fcitx5

If you want your input menu to look a bit nicer (especially if you use Hyprland with a themed setup), there are some great community skins.

With yay installed, you can grab them like this:

# Dark theme
yay -S fcitx5-skin-fluentdark-git

# Light theme
yay -S fcitx5-skin-fluentlight-git

# Material Color theme
yay -S fcitx5-material-color

Then apply the theme:

Right-click the Fcitx5 tray icon → Configure → Addons → Classic UI → Choose your skin.

6. Customize Mozc

Mozc itself has plenty of customization options. You can access them by:

Right-click Fcitx5 tray icon → Mozc Settings

From here, you can tweak:

your input mode
key mappings
dictionary behavior
suggestion style
punctuation preferences

Make it feel natural for your workflow.

Troubleshooting Tips

Here are a few common issues you might run into:

Fcitx5 isn’t starting

Add it to autostart in your DE/WM. For Hyprland users, you can add:

exec-once = fcitx5 &

Input doesn’t work in some apps

Some Electron apps (like VS Code or Discord) need Wayland flags enabled:

Add these flags to their .desktop file:

--enable-features=UseOzonePlatform --ozone-platform=wayland

After that, Japanese input should work normally.

All Set!

Once everything is installed, configured, and themed the way you like, you’ll have a smooth and reliable Japanese input experience on Arch Linux. Whether you're studying Japanese, chatting with friends, or writing notes, this setup is dependable and lightweight — perfect for daily use.

If you want me to prepare the frontmatter + content together in a single file, just say “assemble it” and I’ll package the whole blog post neatly.

Beneath the Masks: A Personal Anime Review of BanG Dream! Ave Mujica

Tue, 15 Apr 2025 00:00:00 GMT

When I heard there was going to be an Ave Mujica anime, I wasn’t sure what to expect. It’s part of the BanG Dream universe, but it doesn’t follow the usual upbeat path. This one leans into a gothic metal tone with characters who wear emotional armor and try to sound louder than their own fears.

This is a review from someone who watched not just the music, but the people behind it. The show is as much about psychology as it is about guitar riffs and set pieces.

What Ave Mujica Actually Is

Ave Mujica isn’t just another band in the franchise. They’re a strange mix of masked performance and emotional unraveling.

Sakiko, known on stage as Oblivionis, forms the band after her old group CRYCHIC collapses. She brings in four other girls, each with their own contradictions, and asks them to become something greater than themselves. And heavier.

Instead of typical band anime energy, their sound goes for gothic symphonic metal. Dramatic. Brooding. Their whole style feels like a metaphor for how every member carries some version of a cracked identity.

Getting to Know the Characters

The thing that surprised me most is how much the show cares about who these characters are. It doesn’t rely on tropes. It slows down and lets you feel what they’re struggling with.

Sakiko Togawa (Oblivionis)

Sakiko’s story is the one that keeps pulling me back. She watched CRYCHIC fall apart and watched her old friends move forward without her. Starting Ave Mujica almost feels like a shield.

Her stage persona means “to forget,” but the show makes it clear she never really forgets anything. She buries it under control, perfection, and a need to rewrite her own history.

There are scenes where she looks like she’s keeping the entire band together through sheer willpower, even while she’s falling apart inside. It’s hard not to feel for her.

Mutsumi Wakaba (Mortis)

Mutsumi’s story hurts in a very human way. Her relationship with Mortis isn’t a gimmick. It feels like a person trying to survive by splitting off the parts of themselves that can take the hits.

When Mortis appears, it’s not an edgy moment. It’s a cry for help. And the show treats it that way.

Their back and forth makes up the emotional center of the series for me. It’s identity laid bare in the most dramatic and painful way.

Nyamu Yutenji (Amoris)

Nyamu is that chaotic presence you can’t look away from. She’s loud, charming, and unpredictable. She wants attention and isn’t shy about it.

Her persona means “of love,” which fits because she chases affection like it’s her life force. At first she looks like comic relief, but she becomes a foil to Sakiko’s rigid world view.

She forces the band to confront their own strictness. And she makes the group feel alive.

Uika Misumi (Doloris)

Uika holds herself in a way that always looks composed. That calm hides a lot of pressure though.

She has experience in another idol unit, and it gives her a strange duality. Bright idol on one side, dark metal guitarist on the other. She’s always aware of both worlds and you can feel the weight on her.

Umiri Yahata (Timoris)

Umiri is quiet but extremely precise. Everything she does is measured. Her persona means “fear,” and it reflects her perfectionism well.

What I like about her arc is that it never turns her into someone she’s not. She doesn’t suddenly become loose or carefree. She learns how to move forward without erasing the parts of herself that still worry.

Why the Show Works

The gothic visuals aren’t just there for style. They mirror the themes. Masks hide truths we don’t want to face. Personas become shields. Every member of the band is trying to figure out who they are under the makeup and the costumes.

The animation leans into this. Shadowed stages. Sharp highlights. Close-up shots that feel like confessions. The music doesn’t act as background either. It feels like the only language these characters can use to say what they can’t put into words.

Some Flaws, But Nothing Deal-Breaking

The show has a few rough edges.

Some symbolic moments lean a bit too dramatic. A few scenes assume you already know the emotional weight they’re referencing. And this isn’t a gentle entry into music anime. It starts heavy and stays that way.

Even with those flaws, the series never wastes the emotion it builds.

Final Thoughts

For me, Ave Mujica feels like watching people pour themselves onto a stage and trying to make something beautiful out of the mess.

It isn’t just a band story. It’s a story about people trying to pull themselves together, even when they already expect to break again. Somewhere in that chaos, they find moments of harmony.

Rating: ★★★★★ (5/5) Not just for the music, but for how deeply I felt every beat of these characters’ hearts.

Reference

Computers Were Faster When They Were Slower

Sat, 30 Nov 2024 00:00:00 GMT

There’s a strange truth about modern computing. Machines today are faster, lighter, and capable of doing far more than the ones we grew up with. Yet they often feel slower when you open an app, load a website, or try to do something simple.

The problem isn’t the hardware. It’s the software we run on top of it.

The Promise of Moore’s Law

Moore’s Law predicted that transistor counts on integrated circuits would double about every two years. For decades, that meant computers would get faster and more capable at a steady, almost predictable pace.

And for the most part, this held up. Hardware has become absurdly powerful compared to what we had in the past. Even a budget phone today can run circles around high-end desktops from the early 2000s.

But while the hardware raced ahead, software development took a different path.

The Reality of Modern Software

In the early days, developers wrote programs like every byte mattered. Memory was limited. Storage was tiny. CPUs crawled. You had to be careful and intentional.

Today the mindset is different. Hardware is “good enough,” so efficiency is treated like an optional bonus. The result is software that’s larger, slower, and full of features most people never touch.

A simple example is the text editor. Years ago, it opened instantly and used a tiny amount of memory. Today, many editors load entire frameworks, sync accounts, run background processes, and ship with plugins you never asked for.

The tool is the same, but the experience is slower.

The Bandwidth vs Processing Paradox

We have faster internet, quicker storage, and stronger CPUs. Websites should load instantly. Web apps should feel snappy. Most don’t.

Modern sites stack frameworks on top of frameworks. They load megabytes of scripts to display a few paragraphs of text. The speed we gain from better hardware gets erased by layers of complexity.

A faster connection doesn’t help much when a site insists on loading twelve analytics trackers and half a megabyte of CSS.

A Small but Embarrassing Example

A developer once needed to number the lines in a text file. Instead of using the built-in Unix command nl, which does this instantly, they wrote a Python script that looped through the file line by line. It was slower, more complicated, and solved a problem the system already handled.

This isn’t rare. Many developers simply don’t know what tools already exist. They default to writing new code, often without thinking about performance, because writing feels easier than learning.

The Weight of Abstraction

Modern software leans heavily on abstraction layers. Frameworks on top of frameworks. Libraries wrapped inside other libraries.

Abstraction helps developers build things faster, but every extra layer adds cost. A small web app might load dozens of dependencies just to show a few buttons. Each library adds memory use, CPU time, and maintenance overhead.

None of this is visible to the user. They just feel the lag.

The Snowball Effect

One slow tool is manageable. A hundred slow tools running at once is a different story.

That’s where we are now. Even with hardware that is thousands of times more capable than what we had in the past, the software stack is so heavy that the performance gain gets eaten alive.

You can see this in:

browsers that use gigabytes of RAM
operating systems that launch dozens of background processes
games that rely on upscaling to compensate for inefficient rendering pipelines

The hardware is strong. The software is what’s slowing us down.

The Path Forward

We don’t need to abandon modern tools. They’ve made development more accessible and allowed people to create things that would have been impossible a decade ago.

But we do need a shift in mindset. Developers should:

learn the system tools that already exist
write code with performance in mind
avoid dependencies that don’t add real value
build with intention instead of convenience

Minimalism isn’t about doing less. It’s about doing what matters and doing it well.

Conclusion

Computers are faster than ever, but they rarely feel that way. Moore’s Law keeps pushing hardware forward, but software often pulls the experience back.

If we want machines to feel fast again, we need to treat efficiency as a priority instead of an afterthought. Otherwise we’ll stay stuck in a strange loop where better hardware gives us slower programs.

Social Media and the Mechanics of Behavioral Influence

Sun, 08 Aug 2021 00:00:00 GMT

An American psychologist named B. F. Skinner (1904–1990) became widely known for the Skinner Box, a device used in animal behavior experiments. In his research, he placed rats inside a box equipped with lights, levers, and other mechanisms. He programmed the box so that when a rat stood on a lever or pressed it at a certain moment, it might receive a reward, such as a food pellet, or a mild electric shock. Although the experiments involved animals, the ideas behind them were aimed at understanding human behavior.

Skinner later wrote a book titled Beyond Freedom and Dignity, where he explained how he viewed the world. His vision was a kind of behavioral utopia in which every human action is shaped by stimulus and response, much like what happened inside his experimental box.

In this view, people do good social things because those behaviors are rewarded, and they avoid unwanted actions because those behaviors are punished. Skinner believed that “freedom” and “dignity” were abstract ideas, almost illusions. They were metaphysical concepts, not actual goals of society. Social engineers, he argued, could design a system that shapes people to behave as expected.

This feels relevant today because, in many ways, we live inside a modern “Skinner Box,” especially when we think about social media.

Social media is a form of social control. Every platform—Facebook, Twitter, Reddit—functions like a giant Skinner Box. In the early days, these platforms were more open, decentralized, and free. But over time, the people running them realized they could act like social engineers.

What’s striking is that social control on these platforms doesn’t require much effort. They almost run themselves. You can steer people to behave in certain ways simply by shaping how they interact. Even basic tools like banning users are enough. Platforms don’t need to ban many accounts—just enough to create a chilling effect that influences everyone else.

Privacy isn’t the only concern. The deeper issue is how your behavior becomes metadata. The people making decisions might not know you personally, but the metadata is used to train new AI models designed for cognitive influence. These systems can tag content automatically, spread certain messages, trigger hashtags, or push specific recommendations to shape what people see.

We can probably agree that with all this information at our fingertips, it’s becoming harder to “single-task” or devote serious thought to anything that requires sustained attention. A student might deactivate Facebook or ask a friend to hide their phone just so they can finish a lab report in the next four hours.

Sharing has become the norm, and sharing itself isn’t a problem. The issue is that most shared content isn’t meaningful persuasion or thoughtful argument. It simply distracts us from deeper thinking.

As social media and personal technology become even more embedded in the lives of younger generations, the problem will only grow. Small social habits once seen as trivial are increasingly normalized, while the social push toward slow, reflective thinking fades into the background.

Many people believe social media gives them a new voice for revolution and social change. But those who look closer understand that this technological revolution is not like the social revolutions of the past.

I enjoy social media. Being able to connect with others so easily is a real gift to our natural need for friendship and understanding. But we should ask where our time is best spent. Instead of waiting for change after seeing it on your feed, how can what you see translate into your own life? Why is this information shown to me? What purpose does this photo, story, or tweet serve?

Rather than treating social media as the answer to every question in our daily interactions, it’s healthier to treat it as just one more tool for examining the larger issues we face.

Don’t let society or social media bury you under the weight of endless information. Question what you see. Don’t settle into complacency and drift away from the deeper, more demanding forms of thought that make us fully human.