Category: Opinions

Higher education leaders talk about “trust” the way institutions talk about “excellence”: as if repetition can make it real. But students, faculty, staff, alumni, legislators, donors, and the public judge leadership through two distinct ideas: trust and confidence.

The difference matters. A university can restore confidence through competent performance yet fail to rebuild trust after people feel misled, dismissed, or used.

Trust is not confidence

Confidence: “I believe this will work.”

Confidence rests on competence and predictability. It grows from evidence: sound decisions, reliable operations, measurable results, and promises kept.

Trust: “I believe you will act fairly.”

Trust rests on intent, integrity, and relationship. It grows when leaders tell the truth, treat people with dignity, share risk, and allow the institution’s mission to constrain their choices.

The two often move together, but not always:

• Confidence without trust: “They are capable, but I do not believe they are fair.”
• Trust without confidence: “They mean well, but I am not sure they can deliver.”

Universities need both. Where authority is distributed, expertise is specialized, and legitimacy is social, confidence produces compliance; trust produces commitment.

Four kinds of leadership credibility

	High confidence	Low confidence
High trust	Durable legitimacy: people tolerate mistakes because they believe leaders are honest and capable.	Goodwill under strain: people remain sympathetic, but patience fades when execution does not improve.
Low trust	Efficient but resented: short-term results come at the cost of long-term cynicism.	Crisis: stakeholders assume the worst and resist nearly every decision.

The political maneuvering of the past two years—roughly fall 2024 through fall 2026—makes these distinctions unusually clear. The question is not whether government should enforce civil-rights law or whether universities should be accountable. Both are necessary. The question is whether rules are applied consistently and through legitimate procedures—and whether leaders can protect students, scholarship, and institutional independence at the same time.

Leadership under political leverage

Political intervention in higher education did not begin in 2024, but it accelerated and became more routine.

Florida expanded restrictions on the use of state and federal funds for DEI programs across its public system. The state Board of Education described its January 2024 rule as a permanent prohibition on public funding for DEI programs. Texas and other states pursued greater control over DEI, tenure, curriculum, and faculty governance. A 2026 scholarly overview reported that, by spring 2025, lawmakers in 29 states had introduced 134 anti-DEI bills; 19 had become law.

Supporters describe these measures as an effort to reclaim public institutions from unaccountable bureaucracies and ideological conformity. Critics see partisan authorities displacing academic judgment. Either way, university leaders face the same credibility test. Quietly renaming offices or complying through euphemism may preserve operations, but it offers neither a principled defense nor an honest account of institutional constraints.

<blockquote>When political authorities change the rules, leaders must distinguish among compliance, agreement, and advocacy.</blockquote>

Federal pressure intensified in 2025. The Trump administration used research grants, contracts, accreditation, tax status, and authority over international students as leverage over universities. Administration officials said forceful action was necessary to combat antisemitism and unlawful discrimination. Universities and higher education associations argued that legitimate civil-rights enforcement had become entangled with demands for ideological and governance changes.

This is where trust and confidence can pull in opposite directions. Concession may protect grants, laboratories, jobs, and students—evidence of competent stewardship. But unexplained concessions can weaken trust by suggesting that institutional principles are negotiable. Resistance may demonstrate integrity and independence, but it can also put people and programs at financial risk.

The real test is not whether a leader settles or fights. It is whether the leader explains what is being protected, what is being conceded, who will bear the cost, and where the institution will draw the line next time.

What trustworthy, confident leadership looks like

Apply one standard

Define harassment, disruption, and discrimination before a crisis. Apply those definitions regardless of the people, politics, or cause involved. Selective enforcement may produce order, but it destroys legitimacy.

Separate compliance from endorsement

Leaders should say plainly when the institution is obeying a law it opposed, challenging a demand it considers unlawful, or voluntarily correcting a failed policy. Claiming that every strategic choice was legally required may avoid criticism today, but it invites cynicism tomorrow.

Keep boards from becoming shadow administrations

Trustees should oversee mission, risk, and executive performance. They should not manage curricula or make policy in response to donors, headlines, or social media. When boards bypass shared governance, even defensible decisions begin to look political.

Defend civil rights and academic freedom together

These principles are not natural enemies. Universities lose credibility when they protect expression but ignore harassment—or invoke safety to suppress lawful dissent. Leaders must explain how both commitments operate in practice, especially when they collide.

Make concessions visible

Private deals invite speculation. When confidentiality is legally necessary, leaders can still disclose decision criteria, responsible authorities, review dates, and foreseeable costs. Transparency does not require revealing everything; it requires refusing to hide what can responsibly be shared.

Build coalitions before the ultimatum

A president acting alone is easy to isolate. Faculty, students, peer institutions, scientific organizations, alumni, and civic leaders can provide legitimacy that no press release can manufacture.

How leaders lose both

Trust erodes quickly when leaders:

• Rewrite principles after discovering which position is politically safer.
• Invoke “institutional neutrality” only for controversies they prefer to avoid.
• Announce emergency policies without definitions, end dates, or appeals.
• Present strategic concessions as unavoidable legal requirements.
• Treat students and faculty as reputational liabilities rather than members of the institution.
• Defend autonomy in public while allowing donors, trustees, legislators, or federal officials to exercise control in private.

The deepest danger is not that universities may move left or right. It is that their communities may stop believing decisions are governed by stable rules. Once that happens, competent decisions look partisan, and principled decisions look performative.

The bottom line

Higher education does not run on hierarchy alone. It also depends on expertise, norms, and shared governance. Leaders cannot “message” their way into legitimacy.

Confidence is earned by doing what you said you would do.

Trust is earned by showing, repeatedly, that the institution’s values constrain your choices rather than decorate your speeches.

Universities that build both can withstand political pressure, adapt to change, and remain institutions worth believing in.

Selah.

If you spend any time watching C++ conference talks, reading the standard, or skimming the Core Guidelines, you could be forgiven for thinking the industry quietly agreed to rewrite itself overnight. The code in those talks is elegant. Expressive. Composed of ranges, concepts,constexpr, value semantics, and a conspicuous absence of raw pointers.

In college, though, C++ often shows up in a different outfit: data structures, intro systems, maybe compilers or graphics if you are lucky. It is taught as “the language you use to understand memory,” not “the language you use to write elegant libraries.” Students learn pointers early. They learn manual lifetime management. They learn to fear undefined behavior.

Then you open a real codebase, written by a team that ships products for a living.

And… yeah. Something is off.

So let’s ask the uncomfortable question out loud: is anybody actually writing C++ the way C++20 suggests?

The answer is yes. But not in the way most people mean.

What “the C++20 Way” Even Is

When people say “modern C++,” they rarely mean one feature. They mean a style that has emerged over the last decade: code that leans on value semantics and RAII, prefers standard algorithms over bespoke loops, uses strong types to make illegal states harder to represent, and pushes intent into the type system instead of into comments.

In practice, “the C++20 way” usually looks like a handful of recurring moves. You see

std::optional

and

std::variant

where older code used sentinel values. You see

enum class

where older code used loosely-typed integers. You see concepts where older template code relied on SFINAE and error messages as a rite of passage. You see

constexpr

used to make compile-time decisions explicit rather than accidental.

And, maybe most importantly, you see fewer macros, fewer raw owning pointers, and fewer surprise lifetime rules.

None of this descended from on high with a standard release. It grew out of guidelines, talks, libraries, and hard-won experience. It is not “how C++ must be written.” It is how C++ can be written when everything goes right.

Who’s Actually Writing C++ This Way?

Some people really are writing the C++ from the talks. It is not imaginary. It is just concentrated in a few places.

Library authors and C++ specialists

If you work on standard library internals, Boost-like libraries, header-only abstractions, compilers, or tooling, this style is not aspirational. It is necessary.

These teams spend all day living in templates. They are the reason concepts exist. They treat

constexpr

as a feature, not a punishment. Their code looks like the talks because they are the ones giving the talks.

Greenfield, performance-heavy projects

New subsystems and high-end projects are the next most likely place to find “conference C++.” Think simulation, robotics, finance, and HPC, where performance and correctness are non-negotiable and the codebase is not dragging decades of baggage.

Even here, adoption is cautious. Smart pointers become the default, but they do not replace every custom allocator. Expressive types show up, but teams still measure every abstraction. Ranges do not replace every loop. Modules exist mostly in slide decks. Compile-time complexity is treated as a real cost.

It is modern, but it is modern with a budget.

Teaching environments

Academia can produce the cleanest C++ precisely because it can ignore so many constraints. When you are not supporting four platforms, three compilers, and one vendor-patched standard library, you can teach the simpler story: avoid raw owning pointers, express intent in types, and let the compiler enforce invariants.

Students often learn a cleaner C++ than they will see in their first job.

That is not a bug. That is a north star.

Who Mostly Isn’t Writing C++ This Way?

If “conference C++” were the median, this essay would not exist. Most production C++ lives under constraints that talks rarely linger on.

Legacy codebases

Millions of lines of pre-C++11 code do not get magically modernized because a new standard dropped.

Modernization is usually incremental and local. You modernize at boundaries, where it is safe. You introduce a new type here, replace a few ownership patterns there, move a subsystem toward a newer dialect when you can, and leave the rest alone unless you enjoy production outages.

These teams live in a hybrid world: “modern where possible, old where required.” And that is often the correct choice.

Cross-platform product teams

If you support old compilers, niche platforms, embedded targets, or vendor-patched libraries, you cannot assume full C++20 support.

So you end up writing C++17-ish core logic, adopting a few C++20 features where they help, and building careful fallbacks. This is not conservatism. It is survival.

Game studios

Games deserve special mention because they are often very modern, but almost never ideological.

Game teams care about debuggability, build times, and predictable performance. They use RAII everywhere. They use smart pointers where they fit the engine’s ownership model. Exceptions are often banned. Heavy abstractions and ranges show up selectively, because the cost is paid by every developer who has to build, debug, and profile the game.

Game C++ looks modern, but it does not look like a conference slide.

And it should not.

The Uncomfortable Truth

The C++ standard does not describe how people do write code. It describes how people could write code if starting today, with no legacy constraints, excellent toolchains, uniform compiler support, and deeply trained developers.

Real codebases are messier, older, and more political than that.

What’s Actually Happening in Practice

C++20 has not become doctrine. It has become a toolbox.

Teams adopt what pays for itself. They take the features that reduce bugs. They take the features that clarify intent. They take the features that do not explode compile times, onboarding, or debugging.

And they ignore the rest. Sometimes that is shortsighted. Often it is wise.

This is not failure. It is engineering.

A Hot Take Worth Saying Out Loud

C++20 is not a style guide. It is a pressure gradient.

New code drifts toward it. Old code resists it. Great engineers use it deliberately. Poor engineers misuse it and blame the language.

The difference is not the standard.

It is judgment.

A Note for Educators

If you teach C++ “the C++20 way,” you are doing the right thing, as long as you are honest about reality.

Teach it as the ideal we aim for, not the average codebase someone will inherit. The students who understand that distinction tend to become better engineers faster, because they learn both the direction of travel and the constraints that slow it down.

Final Thought

The right question is not “Is anyone writing C++ like the standard suggests?”

It is: “Which parts of modern C++ meaningfully improve this codebase?”

That is the question professionals actually answer every day.

And it is the real lesson C++20 teaches.

Fair warning: I have strong opinions 😄

Selah.