University of North Carolina moves to define academic freedom – Asheville Citizen-Times

EDUCATION

UNC System moves to define academic freedom, battles profs union

By Clayton Henkel, NC Newline, Asheville Citizen Times, Jan. 30, 2026, 6:04 a.m. ET

The UNC Systems’ Committee on University Governance gave an initial nod Wednesday to a formal definition for academic freedom.

“Academic freedom as a concept is included in our code and has been for some time,” explained Andrew Tripp, UNC System’s senior vice president and general counsel. “What has been lacking is a definition of academic freedom for both faculty and students.”

Tripp said university leadership identified that gap over a year ago and tasked the chair of UNC’s Faculty Assembly and others to work out a consensus definition that could govern how university campuses operate.

“It does a couple of things — that definition defines [academic freedom] in words that our faculty assembly have provided, but it also talks about what academic freedom is with concrete examples and where it applies most pointedly to protect the classroom and course development, research, and scholarly inquiry,” Tripp said.

The proposed policy also defines what academic freedom isn’t, which is important to acknowledge, Tripp told members of the Board of Governors.

“I think it’s a good balance of what the responsibilities we have are and what the opportunities we have are, because academic freedom is critical to us using our expertise to do the teaching and research the faculty are supposed to do,” Maki said.

The policy defines academic freedom as “the foundational principle that protects the rights of all faculty to engage in teaching, research/creative activities, service, and scholarly inquiry without undue influence. It ensures that faculty can freely pursue knowledge; express, discuss and debate ideas; and contribute to knowledge and understanding related to their areas of expertise.”

The policy further states that faculty have the rights and responsibility to determine “pedagogical strategies, instructional materials, evaluation methods, and classroom discourse that supports student learning” provided those methods align with professional standards.

But the policy also cautions that academic freedom is not absolute.

Under the policy, faculty are expected to exercise academic freedom that falls “within the parameters established by academic disciplines, professions, and in compliance with institutional policies and rules.”

Other guardrails spell out that academic freedom does not permit instructors to teach content “clearly unrelated” to the course description or to use university resources for political or ideological advocacy.

The North Carolina State Conference of the American Association of University Professors says that proposed revisions to the policy differ considerably from language adopted in the UNC Faculty Assembly’s Resolution on Academic Freedom back in October 2025.  What started as six lines defining the limitations of academic freedom last fall mushroomed to 35 lines when presented this week.

“That’s a really big increase, and that increase was not done in a way that was presented with shared governance, but that increase was done with very little faculty input over the holiday break when very little faculty were even available to weigh in,” said Annelise Mennicke, a AAUP member and associate professor in the School of Social Work at UNC-Charlotte.

Attorneys for NCAAUP say the list of parameters effectively weakens the historical scope of academic freedom.

“Much of the language in the Resolution and proposed additional language is also vague and, therefore, risks creating an academic environment that is inconsistent with principles of academic freedom and free speech articulated by the United States Supreme Court and the Fourth Circuit,” NCAAUP attorneys write in a January 26 letter to the UNC System.

Editor’s Note: Read the rest of the story, at the below link.

Continue/Read Original Article Here: University of North Carolina moves to define academic freedom

Latest #DesmetC "explorations with machete and torch": the compiler source has numbered constants for each supported C datatype. Normally you'd use enum for this sort of thing, but this codebase used #defines. The constants were numbered in a strange order, and I wanted to re-sort them in the order of the "usual arithmetic conversions", to simplify some logic. This broke code-gen, emitting illegal instructions. Several hours later, I found that CCHAR=1 and CINT=2 were directly used in hex math determining which x86 opcode to emit. When I renumbered those constants, it caused absurd instructions to be generated. After correcting that problem, we are now back to self-hosting o.k.
I'm hoping this will make it possible to retire a bunch of one-off type promotion logic scattered around the compiler, in favor of a few central functions closely mapping to the C89 standard.

#retrocomputing #SoftwareArchaeology

@shugo gcc -EするとNULLが/usr/lib/gcc/x86_64-linux-gnu/13/include/stddef.hでdefineされていることがわかって、下記のように、Cなら(void *)に、C++なら整数になるみたいです。

:
#if defined (_STDDEF_H) || defined (__need_NULL)
#undef NULL /* in case <stdio.h> has defined it. */
#ifdef __GNUG__
#define NULL __null
#else /* G++ */
#ifndef __cplusplus
#define NULL ((void *)0)
#else /* C++ */
#define NULL 0
#endif /* C++ */
#endif /* G++ */
#endif /* NULL not defined and <stddef.h> or need NULL. */
#undef __need_NULL
:

@zundan 最近の規格知らないのですが、#define NULL ((void *)0)じゃなくて#define NULL 0として定義されているのにコンパイラが特別扱いしているということですか

いたいた。型キャストしてないNULLも居るけど条件分岐してるんだろうな

$ grep NULL /usr/lib/gcc/x86_64-linux-gnu/13/include/stddef.h
:
#define NULL ((void *)0)
#define NULL 0
:

## は ANSI-C定義で普通の文でも使えるはず（#define くらいしか使いどころがないのはそう）

@jplatte True! 😅

Though for how much the C preprocessor gets made fun of, it's surprisingly strict with some things.

Like how macro names must be valid identifiers or how comments are removed before its invocation, so

```c
#define MY_COMMENT / ## /

MY_COMMENT bla bla
```

sadly doesn't work.

Solaris 10 is also not very smart, so I have to:

/*
* on Solaris 10, we need to manually specify NI_MAXSERV and NI_MAXHOST, due to libc defficiencies
*/
#define NI_MAXSERV 32
#define NI_MAXHOST 1025

@vitaut maybe you should add some defines to make it easier for them to understand

#define fn auto
#define let const auto
#define let_mut auto

@ska @ariadne

     case TOKEN822_COMMA:
       *s++ = ',';
#define NSUW \
 s[0] = '\n'; s[1] = ' '; \
 if (linee && (!linelen || (s - lineb <= linelen))) \
  { while (linee < s) { linee[0] = linee[2]; ++linee; } linee -= 2; } \
 else { if (linee) lineb = linee + 1; linee = s; s += 2; }
       NSUW
       break;

The plan: use an LD_PRELOAD library to directly call CmFWImgDecryptHandler and dump the decrypted output. This is, depressingly, the easiest option.

```
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <string.h>

/* README
* mips-linux-gcc -shared -fPIC lib.c -o preload.so -ldl
* go into the rootfs
* qemu-mips -strace -L . -E LD_PRELOAD=./preload.so ISS.exe ./encrypted.hex
* An encrypted.hex_clear file is created
*/

typedef int (*depack_fn)(void *, int *);

/* We need to get the first arg passed to ISS.exe */
static char *get_filename_from_cmdline(void)
{
int fd = open("/proc/self/cmdline", O_RDONLY);
if (fd < 0)
return NULL;

static char buf[4096];
ssize_t n = read(fd, buf, sizeof(buf) - 1);
close(fd);

if (n <= 0) return NULL;
buf[n] = '\0';

/* cmdline = argv[0]\0argv[1]\0... */
char *p = buf;
p += strlen(p) + 1; // skip argv[0]

if (*p == '\0') return NULL;
return p; // argv[1]
}

__attribute__((constructor))
static void preload_init(void)
{
printf("[preload] Calling constructor\n");
/* symbol depack to solve */
depack_fn depack = (depack_fn)dlsym(RTLD_DEFAULT, "CmFWImgDecryptHandler");
if (!depack) {
fprintf(stderr, "[preload] CmFWImgDecryptHandler not found: %s\n", dlerror());
return;
}

char *filename = get_filename_from_cmdline();

printf("[preload] file: %s\n", filename);

int fd = open(filename, O_RDONLY);
if (fd < 0) {
perror("[preload] open");
return;
}

/* ===== get size with lseek ===== */
int len = lseek(fd, 0, SEEK_END);
if (len <= 0) {
perror("[preload] lseek SEEK_END");
close(fd);
return;
}

lseek(fd, 0, SEEK_SET);

fprintf(stderr, "[preload] malloc(%d)\n", len);
void *buf_in = malloc(len);

if (!buf_in ) {
fprintf(stderr, "[preload] malloc failed\n");
close(fd);
return;
}

if (read(fd, buf_in, len) != (ssize_t)len) {
fprintf(stderr, "[preload] read failed\n");
close(fd);
return;
}

close(fd);

printf("[preload] call depack(%p, %zu)\n",
buf_in, len);

int ret = depack(buf_in, &len);

printf("[preload] CmFWImgDecryptHandler return %d\n", ret);

if (ret == 1) {
/* ===== writing output ===== */
char outname[4096];
snprintf(outname, sizeof(outname), "%s_clear", filename);

int fd_out = open(outname, O_CREAT | O_WRONLY | O_TRUNC, 0644);
if (fd_out < 0) {
perror("[preload] open output");
goto cleanup;
}

if (write(fd_out, buf_in, len) != len) {
perror("[preload] write output");
} else {
printf("[preload] file: %s (%d bytes)\n",
outname, len);
}

close(fd_out);
}

cleanup:
free(buf_in);
/* Better to force exit now instead of running ISS.exe */
_exit(0);
}
```
And it works, perfectly.

Oh, version numbers looked awfully similar but the Debian 13 version might work a little better than the Debian 12 one:

Before:

```
src/conf.c: STDCONF (basicauth, ALNUM WS ALNUM, handle_basicauth),
```

After:

```
src/conf.c: STDCONF (basicauth, USERNAME WS PASSWORD, handle_basicauth),
```

Still limiting a little more than what I could do with squid:

```
#define USERNAME "([^:]*)"
#define PASSWORD "([^@]*)"
```

#define NULL -1

『新装版 機動戦士ガンダム 逆襲のシャア BEYOND THE TIME』1巻・2巻、『機動戦士Zガンダム Define』22巻など1月23日配信のガンダムKindle本コミックをピックアップ！
https://hobby.dengeki.com/news/2879271/

#hobby_dengeki #KADOKAWA #Kindle本 #機動戦士Zガンダム #機動戦士ガンダム #ガンダム #逆襲のシャア #BEYOND_THE_TIME #Zガンダム #Define #グリプス戦役 #ガンダムさん #Kindle #漫画

@mcc it oughta be illegal to #define things in header files.

Oh for heck's sake.

#undef Status
#undef Success

This at the top of the file fixes the problem. I'm in #define hell and I don't know why. :(

set(CMAKE_CXX_STANDARD 17) is set in CMake. Oh, and I believe this same code compiled on GCC before, implying something changed with headers or header order.

My questions, I think, are:

1. This smells to me like a #define somewhere doing something weird. Does it smell like that to you too, or could something else be happening?

2. Can I induce CMake to spit out the gcc -E output so I can see what the preprocessor is turning this code into?

(2/2)