Reasonably Random Rants and Raves

Blog

Command-line Knowledge for MacOS: Network Troubleshooting
I am teaching a graduate-level class in computer communications and networking in this semester. One of the first things I do in that class is review the command-line tools you have available for network configuration and troubleshooting. Y’all know I’m an Apple person and I find that, like most command-line level stuff, Apple people are not very cognizant of the power you have with the command-line. So, I thought I’d share some of the notes from my class focused on macOS networking.

macOS ships with a strong set of command-line networking tools. Many of them come from the BSD and POSIX tradition, and work almost exactly the same as they do on FreeBSD, OpenBSD, and Linux. On top of that, Apple adds a set of system configuration and diagnostics tools that integrate with macOS frameworks like System Configuration, NetworkExtension, and the Wi‑Fi stack.

This post is organized in two parts:
- Traditional BSD utilities you can expect on most Unix-like systems
- Apple-specific tools that are especially useful on macOS
Part 1: Traditional BSD utilities (the classics)

These tools are generally stable, script-friendly, and easy to combine in pipelines.

ping and ping6: basic reachability and latency

Use ping to answer two questions:
- Can I reach this host?
- What is the latency and packet loss?
Examples:
```
ping -c 5 1.1.1.1
ping -c 5 [example.com](<http://example.com>)
```
Notes:
- ICMP can be blocked by firewalls, so “no ping” does not always mean “no connectivity.”
traceroute: path discovery (where packets go)

traceroute shows the hop-by-hop path toward a destination.
```
traceroute [example.com](<http://example.com>)
```
Helpful options:
- -n for numeric output (faster; avoids DNS lookups)
- -w to adjust timeout
ifconfig: interfaces, addresses, and link state

On macOS, ifconfig is still the canonical interface tool.

Show all interfaces:
```
ifconfig
```
Show one interface:
```
ifconfig en0
```
Common things to look for:
- IPv4 address (inet)
- IPv6 address (inet6)
- MAC address (ether)
- Status (status: active)
Tip: on many Macs, Wi‑Fi is often en0 and Ethernet is often en1 or another en*, but it varies.

netstat: sockets and routing info (legacy but handy)

netstat can show listening ports, established connections, and routing tables.

Show listening TCP sockets:
```
netstat -anv | grep LISTEN
```
Show routing table:
```
netstat -rn
```
macOS note: for some tasks, netstat is being superseded by tools like lsof, route, and Apple’s newer diagnostics tools, but it is still useful.

route: view and modify the routing table

View the current default route:
```
route -n get default
```
Show the route to a specific destination:
```
route -n get 8.8.8.8
```
Be cautious editing routes on a laptop. In most cases you want to inspect rather than change.

arp: inspect the ARP cache (IPv4 LAN neighbor mapping)

When troubleshooting local LAN issues (wrong gateway, duplicate IPs, suspicious devices), arp can help.
```
arp -a
```
nslookup, dig, and host: DNS troubleshooting

DNS is often the source of “the internet is down” reports. These tools confirm what your resolver is doing.

dig is the most informative:
```
dig [example.com](<http://example.com>) A
dig [example.com](<http://example.com>) AAAA
dig +short [example.com](<http://example.com>)
```
Check which DNS server is answering:
```
dig [example.com](<http://example.com>) @1.1.1.1
```
nc (netcat): quick TCP/UDP testing

nc is great for testing whether a port is reachable.

Test TCP connect:
```
nc -vz [example.com](<http://example.com>) 443
```
Listen on a port (for local testing):
```
nc -l 9000
```
tcpdump: packet capture (the gold standard)

If you want to know what is actually on the wire, use tcpdump.

Capture on Wi‑Fi (en0) and show DNS traffic:
```
sudo tcpdump -i en0 -n port 53
```
Capture HTTPS flow behavior:
```
sudo tcpdump -i en0 -n tcp port 443
```
Pro tips:
- Always start with -n to avoid DNS lookups in your capture output.
- Keep captures narrow (filter early) so you can read them.
lsof: map ports back to processes

When you see “something is listening on port 8080,” lsof answers “what process?”
```
sudo lsof -nP -iTCP:8080 -sTCP:LISTEN
```
This is often the fastest way to diagnose conflicts with dev servers, proxies, or VPN clients.

Part 2: Apple-specific tools (macOS superpowers)

These tools understand macOS network services and configuration layers better than the classic Unix utilities.

networksetup: manage network service settings

networksetup is a friendly CLI wrapper for many settings you would otherwise click through in System Settings.

List network services:
```
networksetup -listallnetworkservices
```
Show Wi‑Fi info for a service name:
```
networksetup -getinfo "Wi-Fi"
```
See DNS servers configured for a service:
```
networksetup -getdnsservers "Wi-Fi"
```
Set DNS servers (example):
```
sudo networksetup -setdnsservers "Wi-Fi" 1.1.1.1 1.0.0.1
```
Tip: macOS has multiple “network services” (Wi‑Fi, Ethernet adapters, Thunderbolt bridges, VPN interfaces). Troubleshooting often gets easier once you know which service you are actually using.

scutil: System Configuration and name resolution details

scutil is lower-level than networksetup and is extremely useful when configuration looks correct in the UI but behavior is still odd.

Show current DNS resolver state (one of the best troubleshooting commands on macOS):
```
scutil --dns
```
Show proxy configuration:
```
scutil --proxy
```
Get the “primary” network interface/service in use:
```
scutil --nwi
```
ipconfig (macOS): DHCP and interface address details

On macOS, ipconfig is not the Windows tool. It is a small utility mainly for DHCP and interface state.

Get the IPv4 address of an interface:
```
ipconfig getifaddr en0
```
Renew DHCP lease:
```
sudo ipconfig set en0 DHCP
```
system_profiler: inventory network hardware (when names are confusing)

If you are unsure what hardware exists (especially with docks/adapters), system_profiler can help.

Wi‑Fi details:
```
system_profiler SPAirPortDataType
```
Network hardware list:
```
system_profiler SPNetworkDataType
```
log show: read macOS unified logs for networking clues

When problems are intermittent, the system logs can expose DHCP renewals, Wi‑Fi roam events, and VPN behavior.

Example (last hour, filtering for Wi‑Fi keywords):
```
log show --last 1h --predicate 'eventMessage CONTAINS[c] "Wi-Fi"'
```
This is powerful but can be noisy. Narrow your time window and predicate.

Wi‑Fi diagnostics: airport

Apple ships a Wi‑Fi utility called airport. It is not always on your PATH, so you typically run it via the full path.

Show Wi‑Fi link status (SSID, RSSI, channel, rates):
```
/System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport -I
```
Scan for nearby networks:
```
/System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport -s
```
If you troubleshoot Wi‑Fi often, airport -I is the quickest “is my signal bad?” check.

dns-sd: browse and test Bonjour / mDNS service discovery

macOS heavily uses Bonjour (mDNS) for printers, AirPlay, and peer discovery.

Browse services of a type (example: AirPrint):
```
dns-sd -B _ipp._tcp
```
Resolve a service instance:
```
dns-sd -L "Some Printer" _ipp._tcp local
```
A practical troubleshooting flow (putting it together)

When a Mac has “network issues,” a repeatable flow saves time:
1. Link + IP
  - ifconfig en0
  - ipconfig getifaddr en0
2. Default route
  - route -n get default
3. DNS
  - scutil --dns
  - dig [example.com](<http://example.com>)
4. Reachability and path
  - ping -c 5 1.1.1.1
  - traceroute [example.com](<http://example.com>)
5. Ports and processes
  - nc -vz [example.com](<http://example.com>) 443
  - sudo lsof -nP -iTCP -sTCP:LISTEN
6. Packet capture (when you must prove what’s happening)
  - sudo tcpdump -i en0 -n ...
Closing thoughts

The biggest shift on macOS is not that the Unix tools are missing. It is that the configuration and behavior often live in higher-level macOS systems (network services, DNS resolver stacks, Wi‑Fi frameworks, VPN profiles). Knowing when to reach for scutil and networksetup is what turns “I can’t reproduce it” into actionable information.

If you only memorize three commands for macOS-specific diagnostics, make them:
- scutil --dns
- networksetup -listallnetworkservices
- airport -I
January 15, 2026
The Future of On-Campus Courses in a Predominantly Online World
For 25 years, higher education has wrestled with one question: If students can learn online, why come to campus?

The answer: on-campus learning isn’t disappearing—it’s transforming to do what online cannot.

Content Delivery Is Moving Online

Online platforms and AI tutors have become the most efficient way to deliver information. Lectures, readings, and examples thrive in digital spaces where students can pause, rewind, and revisit.

The campus is no longer the best place for one-way information transfer.

On-campus courses will thrive by providing experiences that cannot be digitized:
- Hands-on labs with specialized equipment
- Design studios and maker spaces
- Collaborative team-based work
- In-person research with faculty
- Real-time problem-solving under guidance
The future classroom looks less like a lecture hall and more like a studio, lab, or incubator.

The Campus’s Strongest Differentiator: People

For most students, the real value of campus has never been the lecture—it’s been the people:
- Belonging and connection
- Clubs, teams, and organizations
- Faculty mentorship
- Friendships and peer networks
- Leadership and service opportunities
AI can personalize instruction, but it cannot replace human relationships.

Athens State as a Use Case

My employer, Athens State University, serves a geographically dispersed, working-adult population as a predominantly online institution. Yet the campus remains vital—not for lectures, but as a specialized space for high-impact, hands-on learning.

Computing students come to campus for experiences that cannot be replicated online: cybersecurity labs, IoT and networking environments, undergraduate research, and deeply interactive experiences that complement flexible online programs.

Hybridization Is the Default

The false binary of “online vs. on-campus” is evaporating. What emerges is hybrid by design:
- Lectures watched ahead of time
- Class time for application, coaching, and creation
- AI helps students practice and simulate
- In-person meetings during critical learning phases
- Flexibility during less critical weeks
My CS 318 (Computer Science 2) course exemplifies this: lectures are asynchronous and recorded; class meetings are live-streamed for in-person or online attendance. A significant minority perform better with direct interaction. We use class time for structured programming labs, with plans to add code reviews and breakout activities.

AI Raises the Bar

AI tutoring makes it easy for students to master procedural content independently. This shifts the question:

Why attend in person if an AI tutor can explain the content 24/7?

The answer must be compelling. In-person courses must emphasize:
- Creative synthesis and judgment under uncertainty
- Real-time collaboration and improvisation
- Peer critique and feedback cycles
- Experiential learning with real consequences
Campuses must deliver the parts of learning that require being alive, alert, and in the room.

The Campus Becomes Professional Infrastructure

In applied fields, the campus functions less as a place for listening and more as a place for doing professional work:
- Running experiments
- Configuring hardware, networks, and security systems
- Building prototypes
- Practicing industry-standard workflows
- Working in labs and studios
Future students might take 70% of their content online, but complete 100% of their professional practice in hybrid and in-person environments.

Enrollment Economics Will Reinvent Campus

As flexible online pathways become standard, institutions will restructure their physical spaces:
- Fewer traditional lectures
- More active learning classrooms and labs
- More spaces for team projects
- More tutoring and success centers
- More events and community engagement
Campuses evolve from information centers to creation and connection centers.

Dreamscape Learn as an Example

Dreamscape Learn (https://www.dreamscapelearn.com/) exemplifies this transformation. A collaboration between Hollywood storytellers and academic leaders, it brings cinematic-quality VR into higher education. Originally developed with Arizona State University, Dreamscape creates immersive, narrative-rich VR environments where students work together in shared virtual worlds.

These VR labs turn complex subjects—biology, physics, environmental science—into interactive simulations requiring investigation, collaboration, and problem-solving. The campus becomes the gateway to high-impact, immersive learning that cannot be replicated online. VR laboratories become collaborative hubs where students form communities around exploratory challenges, demonstrating how physical spaces can offer deeply interactive, emotionally resonant learning that fuses storytelling, simulation, and teamwork.

So What Is the Future?

Not extinction. Transformation.

Online education handles:
- Content delivery
- Self-paced mastery
- Flexible pathways
- Practice and basic tutoring (via AI)
On-campus education focuses on:
- Human connection
- Judgment, creativity, and synthesis
- Teamwork and communication
- Studio, lab, and project-based learning
- Identity development and mentorship
The campus becomes a premium experience—not the default, but the valuable. Students show up not because they “have to,” but because something worth experiencing happens there.

Conclusion: The Future University Is a Network

The future of higher education is networked—a connected ecosystem where AI provides constant support, online platforms provide flexibility, the campus provides community and practice, faculty guide through mentorship and design, and students move fluidly between digital and physical experiences.

In a world where almost anything can be learned online, on-campus courses will thrive by becoming deeply human, intensely interactive, and uniquely experiential.

Three Key Insights

1. Physical Affordances Matter—But Only if They’re Superior

Labs, equipment, studios—things that cannot fit through a screen. But this only works if the equipment is meaningfully better than what students could access elsewhere. A basic computer lab isn’t defensible; a VR development lab or cyber range is.

2. The Campus Becomes a Premium Tier

Real-time collaboration, mentorship, peer learning. Even when only a minority perform better with direct interaction, those small percentages matter when competing on outcomes. The campus shifts from default tier for everyone to premium tier for students who need high-touch interaction.

3. Human Social Capital Appreciates in an AI World

In an AI-saturated world, human social capital becomes more valuable, not less. The network you build in college may be worth more than the skills you learn, especially as skills become commoditized by AI.

Selah.
December 7, 2025
Online Education: Changes in Attitude, Changes in Modality
For nearly three decades, online education has centered on one question: Is it better to teach online through real-time sessions or self-paced modules? The answer has shifted dramatically—and today’s research reveals a far more nuanced picture than early “either/or” debates suggested.

When universities first moved courses online in the late 1990s and early 2000s, asynchronous instruction dominated. Limited bandwidth and early LMS platforms like Blackboard and WebCT made videoconferencing unreliable. Scholars such as Michael Moore—whose Transactional Distance Theory shaped early distance-ed thinking—emphasized that effective online learning required bridging the psychological gap between teacher and student through well-structured materials and meaningful dialogue, most of which happened via text-based, time-flexible tools.

By the mid-2000s, research consistently found that asynchronous environments supported reflection, deeper discussion, and learner autonomy (Hrastinski, 2008). Asynchronous wasn’t just convenient—it was considered the gold standard for well-designed online education, especially for adult learners balancing work, family, and school.

As broadband expanded and tools like Zoom, Adobe Connect, and Collaborate improved, synchronous online learning became more viable. Studies throughout the 2010s showed that live sessions boosted social presence, helped students maintain momentum, and let instructors respond to confusion in real time. Research also began suggesting that blended approaches—combining asynchronous materials with occasional synchronous meetings—could outperform either model alone.

Still, attitudes remained cautious. Most fully online programs stuck with asynchronous delivery because it scaled well and met the needs of working adults. Synchronous formats were often seen as a nice addition, not a core design element.

The Pandemic: Synchronous Goes Mainstream

COVID-19 changed everything. Practically overnight, Zoom became the global classroom. For many students and instructors, synchronous online learning was their first experience with online education of any kind.

Research from 2020–2022 revealed several key themes:
- Students valued structure. Synchronous classes provided routine during a chaotic period.
- Faculty found real-time teaching easier to manage than designing robust asynchronous modules on short notice.
- Zoom fatigue was real, and bandwidth limitations, childcare demands, and time zone conflicts disproportionately affected lower-income and rural learners.
- Students in hastily converted asynchronous courses often felt isolated or under-supported.
Most importantly, the pandemic normalized synchronous online learning at an unprecedented scale. Many students—especially traditional undergrads—discovered they prefer some real-time interaction online.

Post-Pandemic Research: Changes In Attitude

As researchers have examined online learning beyond the “emergency remote” context, a clear pattern has emerged: neither synchronous nor asynchronous online education is inherently superior. Each offers distinct advantages.

Asynchronous strengths:
- Maximum flexibility
- Self-paced, repeatable content
- Deeper opportunities for reflective engagement
Synchronous strengths:
- Immediate feedback and clarification
- Stronger sense of connection and accountability
- Better fit for discussion-heavy or skills-based courses
Recent meta-analyses find similar learning outcomes across both formats when courses are intentionally designed. Where differences appear, they relate more to student characteristics (e.g., work schedules, self-regulation skills) and course type than to modality.

The most important post-COVID trend is the rise of “bichronous” online learning—a term coined by Martin, Sunley, and Turner (2020) to describe courses that intentionally blend both modes. Students complete core content asynchronously while engaging in targeted synchronous sessions for problem-solving, discussions, or community building. Recent studies show high satisfaction with these hybrids, especially when synchronous time is used strategically rather than habitually.

Generative AI: Killer or Savior of On-line Education

Generative AI is seen by some as the death of asynchronous online education—and by others as its savior. Asynchronous courses rely heavily on content, self-directed learning, and delayed interaction.

The loudest criticism of this approach is that it makes students feel alone, unsupported, and disconnected. But chatbots integrated into the LMS—serving as first-line tutors and discussion thread guides—can provide real-time support in a non-real-time environment.

At the same time, AI is disrupting assessment and causing concern among faculty over academic integrity. The tools make it easy for students to cheat by auto-generating essays, code, and short answers.

The response has been a move toward more open-ended assessments—projects, reflections, case studies, and multimedia submissions—where AI becomes a tool rather than a shortcut. Faculty are also adopting process-based assignments like think-aloud activities, staged coding tasks, or version-controlled writing.

On the flip side, AI makes life easier for instructional designers. Asynchronous courses require tight, highly structured, and carefully planned materials. Here, AI’s ability to rapidly generate and update content—while creating multiple versions of the same concept—lowers the barriers to quality design.

We see AI not as the “killer” of asynchronous online education but as the “enabler” and “accelerator” of bichronous online education. Tools for text, image, and video generation create new opportunities.

The Take-away

For nearly three decades, the distinction between synchronous and asynchronous learning has shaped online education—from course design to student expectations. This evolution began in the bandwidth-limited era when asynchronous experiences defined quality online learning. It continued through the rise of robust synchronous platforms in the 2010s, then accelerated dramatically when the COVID-19 pandemic pushed real-time online instruction into the mainstream. Today, research shows that neither modality is inherently superior. Each offers unique strengths, and students increasingly prefer thoughtful blends that balance flexibility with meaningful interaction. The future lies in treating synchronicity as a design choice rather than a philosophical divide.

AI amplifies this shift by transforming asynchronous learning itself. Intelligent tutors, adaptive feedback systems, dynamic content generation, and AI-integrated assessments reduce the isolation traditionally associated with self-paced courses while elevating personalization and rigor. At the same time, faculty must rethink assessment integrity and guide students in responsible AI use. Asynchronous education is no longer simply “anytime learning”—supported by AI, it’s becoming interactive, adaptive, and deeply student-centered. Together, these trends signal a future where online education is shaped not by the constraints of time, but by intentional design, learner support, and strategic use of new technologies.

Selah.
November 15, 2025
Command Line Knowledge for MacOS: Dealing with Active Directory
Well, we have to play nicely with all of the Windows stuff that is out in the world. In the enterprise, we have to accept that we are going to have to deal with Windows Networking, particularly authentication and authorization services provided by Active Directory.

Apple has improved the integration with Windows Networking over the years but you still have to do a bunch of contortions to get a machine on the network. Note that the following is taken from multiple Apple support sites and some AI assistance.

Joining a machine into an AD domain and configuring it for network authentication requires you to bind the machine to Domain through Directory Services and then configure authentication on the local machine to connect to the AI domain.

1. Bind the Mac to the AD domain

macOS includes the dsconfigad tool (Active Directory connector) which allows you to bind a Mac to an AD domain from Terminal. (Apple Support)

Here’s a typical command (you’ll substitute your values):
```
sudo dsconfigad -add DOMAIN.COM \
    -computer "Mac-Hostname" \
    -username "BindUser" \
    -password "BindPassword" \
    -ou "OU=Computers,DC=DOMAIN,DC=COM" \
    -force
```
Explanation of parameters:
- -add DOMAIN.COM → The AD domain you’re joining.
- -computer "Mac-Hostname" → The name you want this Mac to appear in AD.
- -username / -password → Credentials of an AD account with rights to bind computer objects.
- -ou "…" → The organizational unit in AD where you want the computer object to reside.
- -force → Optional, for example if it was already bound previously, etc.
Other common flags you may want:
```
sudo dsconfigad -domain DOMAIN.COM \
     -alldomains enable \
     -groups "Domain Admins,Enterprise Admins" \
     -packetsign require \
     -packetencrypt require
```
This enables all domains in the forest, adds certain AD groups to the Mac’s “admin” group, and enables packet signing/encryption for LDAP/AD traffic. (Apple Support)

2. Enable network users to log in at the login window

Once the Mac is bound, you need to allow domain users (network accounts) to login at the macOS login window. There are GUI steps (System Preferences → Users & Groups → Login Options → “Allow network users to log in at login window”), but we can achieve this via command line/config defaults.

Command-line approach

You can use the defaults command to set a preference so that network users are allowed to login. Example:
```
sudo defaults write /Library/Preferences/com.apple.loginwindow ENABLEDIRLOGIN -bool true
```
This sets ENABLEDIRLOGIN to true, enabling directory (network/AD) users at login. (Note: this key has been used historically, though exact availability may vary across macOS versions.)

Also ensure that the login window is set appropriately (e.g., “Name & Password” rather than “List of Users”). For example:
```
sudo defaults write /Library/Preferences/com.apple.loginwindow SHOWFULLNAME -bool true
```
Then you may want to restart the loginwindow or reboot:
```
sudo killall loginwindow
```
Mobile/local account caching and mobile user accounts

This is a an important step that some sites wrongly suggest as optional. You really, really, really, really want to use dsconfigad to enable domain users to have mobile accounts. This will cache credentials locally and will permit users to login when offline from the enterprise network. Otherwise you won’t be able to login. We also strongly recommend that you do keep a separate local user for when things go wrong.

Here’s how to enable mobile accounts in MacOS via dsconfigad:
```
sudo dsconfigad -mobile enable -mobileconfirm disable -localhome enable
```
(from the gist example) (Gist)

3. Verification & Pitfalls
- After binding you can check current settings:
```
dsconfigad -show
```
This will display the domain, computer account, OU, mobile account settings etc. (Gist)
- Make sure DNS is correctly configured: the Mac must be able to resolve the domain controllers for your AD domain. Apple’s documentation emphasizes DNS/Kerberos/LDAP for AD integration. (Apple Support)
- If users cannot login:
- Check that “Allow network users to log in at login window” is indeed enabled (GUI or defaults).
- If after login attempt the screen just sits/spins/shakes, it may be waiting on network/LDAP/Kerberos auth. Example case discussed in Apple forums. (Apple Support Community)
- LocalAdmin vs domain group membership: If you want certain AD groups to be local admins (e.g., “Domain Admins”), you’ll include that in the binding via -groups flag. Otherwise domain user logins may succeed but the user may lack local rights.
- For macOS versions and AD interactions: some behaviors may change from version to version (especially around caching or login window UI). Always test in your environment.
CAVEAT: We admit to using AI tools to research and edit this post.

Selah.
November 2, 2025
How Third-Party Course Content Is Destroying Higher Education

Colleges and universities built their reputations on the quality of their teaching and the expertise of their faculty. A degree meant you had learned from scholars who designed, tested, and refined the very curriculum that carried the institution’s name. But in recent years, this foundation has been quietly eroded by the rise of third-party course content providers—companies that package “ready-to-teach” online courses for universities to rebrand as their own.

At first, this outsourcing looked like convenience. Today, it’s corrosion.

1. The Erosion of Academic Integrity

When a university licenses pre-made courses, it gives away its most sacred academic function: curriculum design. Faculty once spent months shaping syllabi to fit local program outcomes, student needs, and institutional missions. Now, many are handed “turnkey” shells built by strangers—often containing outdated information, no local context, and little alignment with departmental standards.

This undermines the authenticity of the university’s promise. Students think they are learning from that university’s faculty, but in truth they are completing a commodity course produced by a contractor. The result is a diploma that increasingly reflects a licensing relationship, not an educational experience.

2. Faculty Deskilled, Then Replaced

Third-party content de-skills faculty. Once instructors are told to “facilitate” someone else’s course rather than create their own, they cease to be educators and become content proctors. Their authority over learning design, assessment, and even grading can be stripped away through automated quizzes and publisher rubrics.

Eventually, administrators notice that if a course can be taught by anyone following a script, it can also be taught by no one—or by the lowest-cost adjunct available. The business model’s logic leads inexorably to layoffs, consolidation, and the hollowing-out of the academic profession itself.

3. Students Lose the Human Element

Education is not the same as content delivery. Learning happens through mentorship, intellectual friction, and local context—when faculty connect a concept to a community, a region, or a student’s lived experience.

Third-party vendors flatten that richness into generic modules designed to scale across thousands of institutions. A course on “Introduction to Business” becomes a cookie-cutter PowerPoint set with no awareness of the local economy, no discussion of regional industries, and no dialogue with students’ realities.

Students sense this disconnect. Surveys repeatedly show that learners in pre-packaged online courses feel less engaged, less connected, and less confident in their instructors’ expertise.

4. The Corporate Capture of the Curriculum

Outsourcing curriculum means outsourcing values. Third-party content providers are not accountable to faculty senates or accrediting bodies in the same way universities are. Their incentives are commercial, not educational.

When companies determine what students learn—and universities merely rent that content—the door opens for subtle corporate bias. Which case studies are used in a business course? Which programming languages are prioritized in a computer science module? Which health data examples are selected in a nursing simulation? Each of these choices embeds an ideology of the marketplace, not of the academy.

5. The Path Forward: Reclaiming Academic Sovereignty

Universities must rediscover what made them trusted in the first place: faculty governance, curricular integrity, and intellectual independence. That doesn’t mean rejecting all collaboration—it means controlling it.

Partnerships with vendors can be tools, not replacements. Faculty should lead course design, adapting external materials where appropriate but ensuring that institutional mission and local expertise remain at the center. Accrediting agencies and state boards should require disclosure when third-party content exceeds a certain percentage of a degree program. Students have a right to know when their “university course” was written by someone who has never set foot on campus.

If higher education fails to reclaim authorship of its own curriculum, it will become a branding service, not an intellectual community.

Closing Thought

The crisis is not about technology or convenience—it’s about ownership of knowledge. When universities surrender that ownership to third-party content companies, they trade centuries of academic tradition for a subscription plan. The result is an education that looks like college but feels like customer service.

It’s time to take the curriculum back.

Caveat: This post was edited with the assistance of AI research and editing tools but all opinions expressed are the opinions of the author.

As always, solely the opinions of the author, your mileage may vary, standard disclaimers apply.

Selah.

November 1, 2025
The Death of Online Education in the Age of ChatGPT
Proponents of online education have claimed to have democratized learning through recorded lectures, quizzes, and scalable platforms. Yet ChatGPT and similar large language models have rendered that model obsolete. What once required structured courses and scheduled instruction can now be achieved through an intelligent, conversational tutor—available instantly to anyone with an internet connection.

Traditional online education operates on a broadcast model: information is packaged and distributed to a mass audience. ChatGPT embodies a dialogic model—it responds, questions, adapts, and rephrases dynamically. Instead of passively watching lectures or submitting fixed quizzes, students can engage in Socratic dialogue, receiving immediate feedback and infinite tailored examples. The pedagogical advantage is immense: personalization replaces standardization.

Economically, this shift is even more radical. Online programs justified their costs by offering scalable access to expert knowledge and institutional credentials. But ChatGPT delivers expertise at zero marginal cost and continuously updates its explanations. When employers can evaluate skill directly through projects and portfolios, expensive online credentials lose their appeal. The value of institutions shifts from information delivery to mentorship, community, and credibility.

Most profoundly, AI tutors change our conception of knowledge itself. Online education treated knowledge as something stored and transmitted. ChatGPT treats it as something generated and negotiated. Learning becomes less about consumption and more about creation through interaction. In this landscape, the institutions that thrive will integrate human mentorship with adaptive, AI-driven exploration—not cling to static courses.

Online education, in its original form, is dead. But in its place emerges something far more alive: a world where learning is immediate, conversational, and personalized beyond anything the MOOC era ever achieved.

We are making rather broad claims but one can back these concepts with research in the higher education arena:
1. Personalised learning/tutoring with ChatGPT and AI
  - A case-study found ChatGPT can provide personalised and instant feedback in a data-science education context. (The Science and Information Organization)
  - A systematic review showed students using ChatGPT perceived improved learning outcomes, personalised experiences and increased engagement. (SpringerOpen)
  - Research found ChatGPT-generated hints led to learning gains equivalent to human tutor-authored hints in mathematics. (PsyPost – Psychology News)
2. Scalability and economic disruption of online education (MOOCs and digital delivery)
  - One study of MOOCs and online learning highlighted that while scalability is a goal, cost- and completion-rate issues remain significant. (The Journalist’s Resource)
  - A review on MOOCs pointed out that even though digital platforms can reduce cost per learner, they still require significant upfront investment and may not yield the expected economies of scale. (ResearchGate)
3. Shift in the model of knowledge transmission
  - A paper titled “Can ChatGPT Facilitate the Implementation of Personal Learning Environments” argues that ChatGPT may push educators to reconsider why and how they teach, reflecting a shift from content delivery to interactive generation. (ERIC)
  - A systematic review of AI chatbots in education found that a key advantage is personalised assistance and adaptive responses, which contrasts with the broadcast model of traditional online courses. (SpringerOpen)
And for the more academically minded:

Personalised learning with ChatGPT
- Albdrani, Raneem N., and Amal A. Al-Shargabi. “Investigating the Effectiveness of ChatGPT for Providing Personalized Learning Experience: A Case Study.” International Journal of Advanced Computer Science and Applications (IJACSA), Vol. 14, No. 11, 2023. doi:10.14569/IJACSA.2023.01411122. (The Science and Information Organization)
- Duong Thi Thuy Mai, Can Van Da & Nguyen Van Hanh. “The Use of ChatGPT in Teaching and Learning: A Systematic Review through SWOT Analysis Approach.” Frontiers in Education, 2024. doi:10.3389/feduc.2024.1328769. (Frontiers)
- Xu, X., Wang, X., Zhang, Y., & Ma, W. “Can ChatGPT Facilitate the Implementation of Personal Learning Environments (PLEs)?” ERIC, 2023. (ERIC Document ED654282) (ERIC)
Economics of MOOCs and online higher education
- Hoxby, Caroline M. “The Economics of Online Postsecondary Education: MOOCs, Nonselective Education, and Highly Selective Education.” American Economic Review, Vol. 104, No. 5, May 2014, pp. 528–33. doi:10.1257/aer.104.5.528. (American Economic Association)
- Weigel, Margaret. “MOOCs and Online Learning: Research Roundup.” Journalists’ Resource, 22 Jan 2014. (blog-style summary of MOOC research) (The Journalist’s Resource)
Shift in knowledge-transmission/learning-model due to AI and generative tools
- Tulsiani, Ravinder. “ChatGPT and the Future of Personalized Learning in Higher Education.” eLearning Industry, 19 Jan 2024. (eLearning Industry)
- Mai, Duong T. T., et al. “The Use of ChatGPT in Teaching and Learning: A Systematic Review …” Frontiers in Education, 2024. (see above) (Frontiers)
Caveat: Yep, this post was researched using ChatGPT. I’ve made an attempt to get it into into my own voice but we shall see how it goes.

As always, solely the opinions of the author, your mileage may vary, standard disclaimers apply.

Selah.
October 27, 2025
Haven’t Done One of These in A Bit: Shrimp and Asparagus Pasta
This is a variant of a recipe I spotted on the internet. Found a mix of both shrimp an asparagus in the freezer, so here goes:

INGREDENTS
- 3 ounces uncooked thin pasta
- 1/2 pound uncooked shrimp (16-20 per pound), peeled and deveined
- 1/4 teaspoon salt
- 1/8 teaspoon crushed red pepper flakes
- 2 tablespoons olive oil, divided
- 8 asparagus spears, trimmed and cut into 2-inch pieces
- 1/2 cup sliced fresh mushrooms
- 1/4 cup chopped seeded tomato, peeled
- 4 garlic cloves, minced
- 2 tablespoons chopped green onions
- 1/2 cup white wine or chicken broth
- 1-1/2 teaspoons basil
- 1-1/2 teaspoons oregano
- 1/4 cup grated Parmesan cheese
- ] Lemon wedges
Directions
- Cook pasta according to package directions.
- Sprinkle shrimp with salt and pepper flakes.
- In same skillet, stir-fry the next 5 ingredients in remaining oil until vegetables are crisp-tender, about 5 minutes.
- Add wine and seasonings. Return shrimp to pan.
- Drain pasta; add to shrimp mixture and toss gently. Cook and stir until heated through, 1-2 minutes.
- Sprinkle with Parmesan cheese. Serve with lemon wedges.
This worked really well for a quick evening supper.
September 21, 2025
My First “Real” Computer

My First “Real” Computer

One of the “ice breaker” type of questions I ask in beginning computer science courses is “What was the first computers that really got you interested in programming?. That leads us to talking about the history of computing and how computing has evolved over the past century.

The two machines that moved me from the “this is fun” to the “this can be a profession” mindset were computers we had in the lab I was part of in my first attempt at graduate school: the Tektronix 4406 and Texas Instruments Explorer LISP Workstation.

The Tektronix 4406 Smalltalk Workstation

Most people know Tektronix for their test equipment, with their oscilloscopes being the thing that most people remember. They still make decent gear. But in the mid-to-late 1980s, Tek was a bit of a corporate dilettante with their hands in a number of things. One of those was a foray into the workstation market with machines based on the Motorola 68000 processors.

Tek was an early player in the Smalltalk ecosystem and by late 1980s was producing a Smalltalk focused 68000 workstation that ran a rather hacked-up version of Bell Labs Version 7 UNIX. My M.S. thesis advisor was an A.I. sort and had managed to get grant money to get one of these machines. He had moved on to other things by this point and just told his graduate students to have fun with it. I had been following Smalltalk since reading a popular press article on the Dynabook project and was seriously geeked out about being able to play with it. This was my first big dive into the Smalltalk language, the Smalltalk programming environment, and the UNIX operating system.

The Texas Instruments Explorer LISP Machine

The thing that had captured my advisor’s attention was a TI Explorer LX Lisp Machine. LISP Machines were interesting beasts as their processors and architecture was designed and optimized to run LISP. Most of the CAD tools for chip design from this period were built using LISP and so TI licensed a design from LISP Machines Int’l. to create the TI Explorer product line. One of the innovations in this design was that it used the NuBus bus architecture, which was one of the early expansion bus architectures. So the LX included a co-processor card that that was basically an independent 68000 UNIX workstation running AT&T UNIX System III.

My boss told me on my first lab in the lab: “Make it work.” So what do I on my first day? Inadvertently do a “rm -rf *” in the root directory on the UNIX co-processor after spending about four hours loading the OS image from tape. Oops, but what can I say as I was definitely a noob at the time.

Fun machine, tho’, as I got to experience the LISP Machine environment and run EMACS as God and Stallman originally intended. A large part of the really weird stuff we see today in GNU/Emacs was a straight UX port from the LISP Machine. Things like the “CTRL-Windows-Alt” modifier keys (CTRL-SUPER-META on the LM). And the operating system was written entirely in LISP and you had the complete source code. And a lot of my sysadmin experience came from having to figure out to make that co-processor work.

The Result

One of the things that got me hired at NCR was they were looking for people with Smalltalk experience. And a lot of the people who worked on the Smalltalk team at Tek migrated to NCR when NCR tried to build a UX Research Center in Atlanta in the late 80s-early 90s. And getting exposed early to these programming environments and people who knew how to use them made me a better programmer.

Selah.

December 22, 2022
How to: Unity and GitHub – Steps to get started
Unity builds a lot of stuff, lots of which are files generated by the tools that shouldn’t be committed to version control.
- Create new empty 3-d project in Unity Editor
- Create a new empty repo in your GitHub account
- Use text editor to add a README.md in the root folder of your project
- Go to GitHub’s archives of .gitignore files and grab the .gitignore for Unity development.
  - Place this file in the root folder for your project
- Execute the following script:
```
git init
git add README.md ,gitignore
git commit -m "first commit"
git branch -M main
git remote add origin https://github.com/adamwadelewis/gallery.git
git push -u origin main
```
- Now add the contents of your Unity project folder to your repo and then commit and
December 19, 2022
How to: Configuring macOS for web development: Part 3 – A Coda to Part 1 & Homebrew
“Wait a moment, you’re using Homebrew?”, you say Dear Reader? “If you are using Homebrew, shouldn’t we use the copy of the Apache that comes with Homebrew?”, you say?

It’s a viable alternative. Just like with PHP and other things, using a package manager like Homebrew to install the web server in user space means that you can keep up a lot more rapidly with upstream changes in Apache. Down side is you have to undo some things in the system and remember to confirm and redo these things when you update macOS.

Let’s go about it… we need to turn off the version of Apache included in the operating system:
```
sudo apachectl stop
sudo launchctl unload -w /System/Library/LaunchDaemons/org.apache.httpd.plist 2>/dev/null
```
This turns off the server and unloads the system install of Apache from the list of services loaded at system startup.

Now we get things up and running with Homebrew:
```
brew install httpd
brew services start httpd
```
One more configuration adjustment: to keep things somewhat clean, Homebrew’s Apache installer defaults to run on port 8080 rather than port 80. This avoids conflicts issues between the system install of Apache and the Homebrew version. But we want the Homebrew version to server pages on the default port.

How to fix this, edit /opt/homebrew/etc/httpd/httpd.conf to switch the listen port to port 80. Use your favorite edit to find the Listen line in the file and make certain it looks like this:
```
Listen 8080
```
Now restart the server using brew services restart httpd.

An opinion

There is a common thread among the different blogs telling you how to do this that recommends you reset the server root to the Sites folder in your home folder. This is not something I recommend you to do as I believe you need to have a separation between production and development code. Feel free to reconfigure Apache in this manner as you wish but I’ll leave figuring how to do this to be an exercise for the reader.

Do go back and apply the changes I introduced in Part 1 of this series to get your home folder configured. All you need to do is adjust the files names to use the configuration files in your Homebrew install.
December 22, 2021