Every file in a Linux system has permissions: who can read it, who can write to it, who can execute it. These permissions are hierarchical—the file's owner has different rights than group members, who have different rights than others. Root has ultimate authority over all files.
This permission system makes the operating system function. Without it, any process could modify any file, leading to chaos, corruption, and security disasters. Proper authority structures enable proper function.
And this technical reality illuminates something theological: authority isn't arbitrary oppression—it's necessary structure that enables flourishing.
The Permission Structure
Linux permissions have three levels:
- User (owner): specific individual with primary rights
- Group: category of users with shared access
- Other: everyone else
For each level, there are three types of permission:
- Read: view the file's contents
- Write: modify the file
- Execute: run the file as a program
This creates a hierarchy without authoritarianism. The owner has ultimate authority over their files, but they can delegate permissions to groups and others as appropriate.
Authority as Stewardship
File owners don't have arbitrary power. They're stewards—responsible for properly managing their files, setting appropriate permissions, enabling necessary access while preventing unauthorized modification.
Biblical authority works similarly. Parents, pastors, employers, governments—these aren't absolute rulers but stewards. They have delegated authority for specific purposes, responsible to exercise it properly.
Jesus taught this explicitly: "You know that the rulers of the Gentiles lord it over them, and their high officials exercise authority over them. Not so with you. Instead, whoever wants to become great among you must be your servant" (Matthew 20:25-26).
Authority is for service, not domination. Like file permissions enabling system function, authority structures enable human flourishing.
The Autistic Authority Tension
As an autistic person, I have complicated relationships with authority. I don't automatically defer to social hierarchies. I question rules that seem arbitrary. I need explicit justification for authority structures.
This sometimes reads as rebellious. But it's not rejection of authority per se—it's difficulty accepting authority that doesn't justify itself rationally.
Linux permissions help me understand legitimate authority. They're not arbitrary—they serve clear purposes. File owners need authority to manage their files. Groups need shared access for collaboration. Proper permissions enable proper function.
When I understand authority's purpose, submission makes sense. When it seems arbitrary, I struggle.
Root Authority
In Linux, root (superuser) has ultimate authority. Root can modify any file, override any permission, change any setting. This is necessary—someone must be able to fix broken permissions, recover damaged systems, maintain overall order.
But root authority is dangerous. Misuse can destroy the entire system. Therefore, root access is carefully controlled—used only when necessary, with appropriate safeguards.
This parallels divine authority. God has ultimate rights over creation—He made it, sustains it, owns it absolutely. But divine authority isn't arbitrary or tyrannical. It's exercised righteously, for creation's good, according to God's perfect nature.
Human authorities are never "root." We're all users with delegated permissions, accountable to ultimate Authority for how we exercise our limited authority.
Delegation and Hierarchy
File owners can change permissions, granting or restricting access. This creates appropriate hierarchies without requiring micromanagement.
A project directory might have the owner with full permissions, the development team with read and write access, and the public with read-only access. This enables collaboration while preventing chaos.
Biblical authority includes similar delegation. God delegates authority to governments (Romans 13:1), parents (Ephesians 6:1), church leaders (Hebrews 13:17), employers (Ephesians 6:5-9). Each has legitimate but limited authority within their domain.
When to Invoke Sudo
"Sudo" (superuser do) allows regular users to temporarily execute commands with root privileges. This is necessary for system maintenance, but it's used sparingly—not for routine operations.
Similarly, there are times to invoke higher authority: when delegated authority is abused, when immediate authority conflicts with ultimate authority, when extraordinary circumstances require it.
Jesus submitted to His parents (Luke 2:51) and to political authorities (paying temple tax, Matthew 17:27). But He also challenged religious authorities when they contradicted God's purposes (Matthew 23).
Submission to delegated authority is default. But it's not absolute—ultimate authority (God) takes precedence over delegated authorities when they conflict.
Read-Only Access
Some files need read-only access—everyone can view them, but only authorized users can modify them. This protects important data while keeping it accessible.
Scripture functions similarly. It's publicly readable—everyone should access God's Word. But authoritative interpretation requires authority—church teaching, theological training, Spirit guidance.
This isn't elitism. It's protecting truth from corruption while keeping it accessible. Just as you don't want random users modifying system configuration files, you don't want just anyone claiming authoritative interpretation of Scripture.
Executable Permissions
Execute permission lets files run as programs—transforming passive data into active processes. Not every file should be executable; making the wrong files executable creates security vulnerabilities.
Spiritual authority includes similar dynamics. Not everyone has authority to preach, lead, or teach (James 3:1). These require specific callings and qualifications, not just desire or enthusiasm.
This isn't about limiting who can serve—it's about protecting the church from damage caused by unqualified leadership. Like executable permissions, teaching authority should be carefully granted based on qualification, not distributed arbitrarily.
Permission Denied
When you try to access a file without proper permissions, you get "Permission Denied." This isn't oppression—it's protection. The file's owner determined that you shouldn't access it, and the system enforces that decision.
Biblically, "Permission Denied" sometimes happens. God denies Moses entry to the Promised Land (Deuteronomy 34:4). Paul's missionary plans are prevented (Acts 16:6-7). We don't always get what we request.
This isn't arbitrary. God, as ultimate Authority, determines appropriate access to various goods, callings, and circumstances. "Permission Denied" might be protection, redirection, or discipline—but it's always purposeful.
Changing Permissions
File permissions can change. The owner can grant or revoke access as circumstances require. This flexibility allows adaptation while maintaining structure.
God similarly adjusts human authority structures. Israel moved from judges to kings. The church developed from apostolic to episcopal structures. Circumstances change; appropriate authorities adapt.
This isn't relativism—it's wisdom. Authority structures serve purposes; when circumstances change, structures adapt to continue serving those purposes effectively.
World-Writable Files
Making files world-writable (anyone can modify) is almost always a mistake. It creates security vulnerabilities, enables corruption, allows destructive changes.
Similarly, authority that defers to everyone equally becomes dysfunctional. Democratic input is valuable, but some decisions require designated authority. Leadership by committee can become leadership by lowest common denominator.
This doesn't justify authoritarianism. But it recognizes that effective function requires clear authority structures, not universal write access to everything.
The American Anti-Authority Culture
American culture tends toward anti-authoritarianism—suspicious of hierarchy, egalitarian in instinct, resistant to submission. This has both strengths (protecting liberty, preventing tyranny) and weaknesses (undermining necessary structure).
Linux permissions show why authority structures matter. Systems need hierarchy to function. Not arbitrary hierarchy, but purposeful structure with clear delegations, appropriate limitations, and accountability.
Rejecting all authority doesn't create freedom—it creates chaos. Like a filesystem where everyone has full permissions to everything, it leads to dysfunction.
Accountability Structures
Linux systems log permission changes. You can audit who accessed what, when, and what they did. This creates accountability—authority holders can be held responsible for how they use their permissions.
Biblical authority includes similar accountability. Leaders will give account (Hebrews 13:17). Authority is delegated, which means the Delegator holds authorities accountable for its exercise.
This should comfort those under authority—abuse will be addressed—and humble those in authority—they'll answer for how they led.
Practical Application
What do Linux permissions teach about biblical authority?
- Authority serves purpose: It enables function, not arbitrary control
- Hierarchy isn't oppression: Proper structure enables flourishing
- Delegation matters: Authority is distributed appropriately, not concentrated
- Ultimate authority exists: God is root; all others have delegated permissions
- Submission is contextual: Default to delegated authorities, but ultimate Authority takes precedence
- Access is differentiated: Not everyone should have same permissions
- Accountability matters: Authority holders will give account
- Flexibility within structure: Permissions can adapt while maintaining order
Conclusion
Linux permissions create hierarchical authority structures that enable system function. Without them, operating systems would collapse into chaos.
Similarly, biblical authority structures enable human flourishing. Not because God arbitrarily decided hierarchies are good, but because created reality works this way. Authority structures, when functioning properly, enable the good that couldn't happen without them.
My autistic need for rational justification helps here. I understand Linux permissions because their purpose is clear. I can understand biblical authority when I see its purpose—enabling flourishing, protecting truth, maintaining order.
This doesn't mean all authority structures are legitimate. Like filesystem permissions, they can be corrupted, abused, set wrong. But the solution isn't eliminating authority—it's correcting corruption and setting appropriate permissions.
We're not root. We're users with delegated permissions, responsible for managing our domains well, subject to ultimate Authority who will evaluate how we exercised our limited authority.
Until Christ returns and all authority is submitted to God (1 Corinthians 15:24-28), we navigate hierarchies—submitting appropriately, exercising authority righteously, appealing to higher authority when needed, always remembering that we're stewards, not sovereigns.
One day, permissions will be set perfectly. No abuse, no corruption, no Permission Denied that isn't wise protection. Perfect authority structure under perfect Authority.
Until then: understand authority's purpose, submit appropriately, exercise authority righteously, and remember that we're all users in a system owned by Another.
Like a well-configured filesystem where every file has appropriate permissions—enabling function, preventing chaos, protecting what matters, allowing access where beneficial.
That's the goal. And it requires authority structures, not their elimination.