That's true, but questions that are difficult to cheat on are both difficult (time-consuming) to create, and difficult (time-consuming) to grade. Which means less time for other stuff, like actually teaching.
I just got the form from the county for this for some improvements to my house, so I can answer. Permits for "improvements" are sent on to the county tax assessor, and they send you a form basically asking for the value of the improvement. Note that "maintenance" doesn't count, only "improvements" (and then only specific improvements; e.g., adding solar doesn't count). The value gets added to your Prop 13 value, but does not trigger a complete reassessment. So it's unlikely that any improvement would result in a 10x tax bill increase, unless you've owned the property for a long time (meaning that your Prop. 13 value was significantly less than the real value of the property).
Those answers were so frustrating to read. The question is explicitly asking "Why does this exist? When would you need it?" and yet most of the answers are "This is what it does." (sometimes with a few snide RTFMs thrown in for good measure).
I can't speak for anyone else, but for me, it's because Python is cumbersome for doing the sorts of things that are easy in a shell. You want to capture the output of a command, parse it as a tab-separated table, extract the 3rd and 4th columns, and then use them to create new users with the values supplying usernames and passwords. Can you do that easily in Python?
> Are we forever going to be stuck with every company trying to reduce complexity by defining their own custom subset of C++?
The problem with doing this is the same as with the idea that one "90% of people only use 10% of Excel's features" so we should be able to make a simpler Excel and capture 90% of the market: all those people use a different 10% subset. It's the same with C++; everyone wants a "simpler" language, but no one agrees on what should be kept and what should be thrown out. C++ is the language that results from putting together everything that everyone needs (and then dealing with the resulting conflicts and contradictions).
I heard a few faculty suggest that at my school and my reply is always, if I fail everyone, isn't that also equitable? (I.e., if "equity" in final grades is your single goal, adding 100 points to everyone's grade, and subtracting 100 points from everyone's grade will have the same effect.) And of course people react with horror and talk about how unfair that would be, revealing that deep down, they really do believe that grades should be tied to student performance.
Some systems don't provide any other option, or make it very difficult to replace the default. I use a grading scheme closer to what the authors propose (although I was using my own system years before Grading for Equity was written) and it's a constant struggle to make Canvas do what I want. I basically have to do all my grading in a spreadsheet offline, and then just upload it into the Canvas gradebook. (Even then it will average things that should not be averaged, and show students a "percentage grade" that has nothing to do with their actual performance, or final grade.)
It's less a matter of someone failing all the early tests but pulling a Hail Mary in the final, and more a matter of someone failing an early test because it took them an extra week to grasp the material; i.e., if the test had been offered a week later, they would have passed. So they still learned everything, just not on the artificial schedule imposed by one-off tests.
The solution I use is to allow later grades to replace earlier grades. This works best if you can assign each graded item to a specific "topic", so that you can say "your grade on each topic is the highest grade you receive throughout the quarter" or whatever. Then at the end, you calculate their final course grade from some combination of the topic grades. (The easiest way is just to set a pass/fail threshold for each topic and then base their final grade on the number of topics passed.) You can adjust the ratio of replacement to averaging so that you're not totally throwing out earlier results, if you want to do that.
The authors of Grading for Equity spoke at my school and the experience was an interesting one: the Humanities faculty constantly tried to move the conversation toward the topics traditionally associated with "equity": systemic racism, how the California college system was designed to exclude everyone but white males, etc. But the authors basically ignored those attempts and gave what (I though) was some really good, practical advice for improving grading practices. A few of their suggestions (preferring partial credit to pass/fail, in particular) came across to me as being motivated more to increase scores than to make them more accurate, but by and large the whole talk was very good.
> When we say "A extends B" we mean a) an instance of A composes in an instance of B b) A implements the interface that B implicitly expresses c) this implementation, by default, delegates to the instance of A from a).
This is probably the best summary of why traditional OOP is often suboptimal I've read. Clearly OOP solves (or solved) a problem that people were having, it's just that it tries to solve too many problems with the same system.
It's also worth noting that fans of "composition over inheritance" usually don't notice or mention that if you go with pure composition, you lose out on point (c) in most programming languages. Very few languages have a built-in mechanism by which a set of operations on type A can be automatically delegated to one of its elements, without at a minimum, listing all the operations to be delegated. So at least at present, traditional inheritance still provides an operation which is not available with composition.
It's more like, if it you can't find it, it doesn't exist. Seeing something published is probably the most common way for academics to "find" something, but if this algorithm was present in a lot of different code bases, made its way into the Linux kernel, etc., that would have been good enough, too.
> Black people accrue psychic trauma every time another news story like this breaks.
> Being able to "examine the issue" without being at this disadvantage is a privilege.
Whenever I read something like this, the cynic in me wants to reply, "If <insert group> are really that psychologically fragile, clearly they're not ready to participate fully in a liberal democratic society, which necessarily requires being to separate oneself and one's emotions from the issues being discussed."
Yeah, I'm not even sure how that would work? Like, if my department goes with a particular textbook, or a certain number of classes all use textbooks from the same publisher, then sometimes we get discounts on things like solutions manuals or custom editions, but I don't know how a publisher would pay a particular professor for picking their textbook.
Multi-cursor/multi-selection as a built-in thing. I'm aware that you can kind of hack this together, but all of Emacs assumes that there will be one selection and one cursor, so hacks don't really integrate nicely with the rest of Emacs.
It sounds like the nature of his business was such that CA thought he didn't have "clients" (plural) but rather a single client spread out over multiple states.
I've been drinking milk so long that I'm just the opposite: water makes my throat feel dry and makes me feel more parched than I was before. While I'm sure it's doing a fine job of hydrating me, it kind of sucks that it makes me feel more thirsty.
Just for curiosity's sake, I built SQLite 3.2.7 (from 2005-09-24) and 2.8.17 (bugfix on the old 2.8 line, from 2005-12-19) and tried this in the shell in both:
sqlite> create table test_tbl ( test TEXT );
sqlite> insert into test_tbl values ( "0123" );
sqlite> select * from test_tbl;
Both give the same output: 0123. Were you using an API wrapper around SQLite that was doing its own coercions, perhaps?
There was an experimental language called Cecil that had "conditional inheritance". You could say things like
class Rectangle:
var w,h
class Square(Rectangle if w == h):
...
You could then overload functions/methods on both `Square` and `Rectangle` and it would call the correct overload depending on the runtime values of `w` and `h`.
PC's didn't have any dedicated sound hardware (unless you had a sound card), so any kind of sound/music playback would have to be done in real-time on the CPU, which didn't leave much for the rest of your game. C64, Amiga, etc. all had dedicated sound chips which could do a lot of the synthesis and mixing without burdening the CPU. (This is the same reason why PCs didn't get side-scrolling games until much later than consoles: consoles had dedicated hardware for scrolling tilemaps and displaying sprites, while PCs just had a memory-mapped framebuffer of pixels.)
That's kind of how Slashdot used to work: you couldn't just up/down vote, you had to pick a reason why, from a list. "Insightful", "Funny", "Informative", etc. for upvotes, "Incorrect", "Trolling", "Off topic", etc. for downvotes. Of course, Slashdot also had meta moderation, where you could occasionally be given the job of up/downvoting other peoples' votes, which in turn influenced how often they would be allowed to vote in the future.