I didn't realize Swagger/OpenAPI had a way to auto-generate its specification. Your comment led me down the rabbit hole and helped me to find a few options that might do the trick.
I agree. Part of the motivation for this post is that I've been doing triage on a maimed branch that got incorrectly squashed.
That being said, the workflow for this project is unlikely to change. And, to be fair, the workflow has its benefits. The project history is very clean, PR code reviews are straightforward, etc.
What's the point of "clean project history" if junior developers accidentally sometimes break entire branches? You can get "clean views" of history with merge commits with things like --first-parent. Most PR tools today let you look at branch as a whole and it doesn't matter if you squash first or not.
Rebase workflows are so much additional work and the benefits don't actually seem worth that extra work. You can use the tools already available to get most of the same "benefits" and there's a lot less likelihood of needing to do a reflog search or deep dive into squashed commmits with no merge hints left of where a hidden three way merge took the wrong path or a need to manually manage some developer's rerere cache.
I'm biased, of course, by hitting so many of these worst case scenarios and being "the only expert" to get people out of them that I just generally don't trust any workflow that involves junior developers doing lots of unsupervised squashes and rebases. I like merge commits. I like having DAG traversal options when I need them (to fix some junior developer's accidentally bad merge; to archeology my way to deeper context around bugs). Those seem like much better "benefits" than "the project history is clean".
I worked at a place that used this workflow and thought it was incredibly annoying. They also had a bunch of custom git commands set up and "trained" you to use those commands. Many people did not know what they actually did, or how to get themselves out of a jam.
I want code that's easy to write and easy to read. No fancy tricks. No decorators, no hundred-character lines for a print statement, no manual memory management or custom operators. A child should be able to use it.
I want code that's easy to maintain and deploy. Never worry about language/tooling versions again. No gcc, no g++, no rbenv, no Maven, no venv/pipenv/poetry whatever.
My target audience is anyone that doesn't have a computer science degree. A language for accountants and office workers. For school teachers and twelve-year-olds.
Throw out the foobar tutorials and Tower of Hanoi logic puzzles.
"Here's how you can download all your students' submissions from Blackboard in one button click."
"Here's how you automatically format a spreadsheet without having to click on every columns."
"Here's how to make your computer wiggle its mouse so you can skip the mandatory attendance checks for your online classes."
Many of your design aims sound a lot like what Java was supposed to be. In particular:
> Something dead simple.
> I want code that's easy to write and easy to read. No fancy tricks. -- no manual memory management or custom operators. A child should be able to use it.
> I want code that's easy to maintain and deploy.
> A language for accountants and office workers. For school teachers and twelve-year-olds.
"Above all, do not lie to yourself. A man who lies to himself and listens to his own lie comes to a point where he does not discern any truth either in himself or anywhere around him, and thus falls into disrespect towards himself and others. Not respecting anyone, he ceases to love, and having no love, he gives himself up to the passions and coarse pleasures..."
Imagine a business that sells deliverable medical testing kits. This business is the best at what they do; they sell more kits than any other organization, they cost less, they're delivered faster, and are superior in any way, shape, KPI, or form imaginable to traditional alternatives. The only issue being that each kit is in fact a bloodletting kit, and their intended use is to inform you which of your four humours is out of balance.
I'm of the opinion that e-proctoring, whatever its privacy concerns, is fundamentally an exercise in "doing the wrong thing faster". Our exams are a poor reflection of student ability. Our exams have no bearing on actual proficiency in the subject matter. Our exams are ineffectual at catching cheaters. Leaving aside any discussion of privacy, e-proctoring (and traditional proctoring) fails to accomplish its fundamental goals.
To automate these exams, to make them ever-more scalable and easier to distribute, is not a victory. We've merely perpetuated a flawed system.
If we want a meaningful assessment of student ability then we need to use better methods. Dethrone exams from our curriculum. Leverage project-based assessments. Use oral exams where feasible. Replace the infinitely looping lecture halls with recorded videos and open-source textbooks. Use the recovered instructor time for something meaningful. This is not a Gordian knot. It can be solved with a little courage and a little pragmatism.
I've been saying this for years, but academia is filled with stupid administrators who are incapable of evolving the state of teaching / learning because their salary depends on having administrative bloat.
I agree that the tools themselves aren't terrible, but I do believe they're an example of "doing the wrong thing faster". My claim would be that all time-limited exams are bad news.
1. The strictness and quality of exams varies significantly by instructor (as you mentioned in your post)
2. Exams aren't representative of any real-world analogue (how often does your boss lock you in a room and tell you to solve the Lagrangian by hand, alone, under a time limit)
3. They don't actually stop determined cheaters (anyone with the foresight to put up notesheets in their bathroom)
In short, proctored exams do not effectively assess student proficiency in a subject, and do not effectively prevent cheating. Making proctoring more scalable means propogating a bad practice at ever-greater rates.
What I would suggest instead, and what many classes in OMSA have already done, is to leverage project-based assessments.
* Demonstrates learning by actually using the material, instead of hollow repeat-backs
* Encourages further learning since practice entails dealing with real-world complications
* Helps students develop a portfolio so they have more to show at graduation than transcripts
There are many other options though if that particular solution doesn't tickle your fancy.
Would you be willing to provide a few references for this? My professional work has skirted around the discussion at times, and I would be fantastically interested in learning more.
I'd like to offer another use case, one near and dear to my heart: grandma.
My grandmother, like many grandmothers, has no business being on the road. She is a wonderful person. She is also a horrible driver, a threat to herself and others by virtue of natural impairments (vision, reaction time, etc.)
Taking away her license would make all roads safer, but it would also obliterate her quality of life. The actual need for driverless cars, to me, is a means of retaining her freedom of movement with a far lower level of endangerment.
I didn't realize Swagger/OpenAPI had a way to auto-generate its specification. Your comment led me down the rabbit hole and helped me to find a few options that might do the trick.