393 karma · joined May 7, 2018
By far one of the most common errors I see as a CS instructor is aggressive over-reliance on global state. Not global methods, but state. However, usually what causes the student to reach for global state is the fact that it can be accessed from a static method like main; In lieu of figuring out how to structure a class, they reach for the easier "just make the variable static" approach. Allowing the initialization sequence to call main on an instance via the class's zero-arg constructor seems like it would address the point.
It helps to think of SQL strings as an untrusted wire format. Yes, parsing is a pain, but it comes with two main benefits: (i) The wire format is human writable/interpretable, with all the accompanying benefits, and (ii) The wire format is easily extensible in a predictable way.
That latter one is particularly useful in keeping SQL's ecosystem open. Take a front-end library like SQLAlchemy or ScalikeJDBC for example. It's not practical for any one such library to support every extension provided by every database engine. SQL provides a fall-back for when you need a back-end feature that hasn't been implemented in any given front-end.
That said, the infrastructure backing Applescript was amazing (especially for the time). The MacOS scripting interface was just as powerful as /proc, but far more structured. Every application and system service defined its own object-relational schema, and Applescript provided a SQL/Sparql-like language for querying that schema ("set foo to all of the Documents"). The schema and associated documentation were self-contained within the applications themselves via the resource fork, and Apple's HIGs set fairly high expectations for the quality of this documentation.
And of course, as the GP notes, other languages could tie into the scripting framework (I have fond memories of using both Frontier and Hyperscript in this way).
Garbage collection has a huge, and generally entirely unappreciated win when it comes to threaded code. As with most things, there are tradeoffs, but every reference counting implementation that I've used has turned any concurrent access to shared memory into a huge bottleneck.
Obviously I'm being a bit greedy here, but much of Framework's value proposition is built around upgradability. Servicing the crowd that actually buys into that proposition first seems like it would be more valuable from a customer loyalty standpoint, even relative to new customer acquisition. These are repeat customers clearly committed to your company's product.
The Framework has a proper cross-brace on the hinge, the hinge mounting points are metal, and I can inexpensively replace the case or hinge if either breaks after the warranty expires.
Support for suspend in linux is definitely shaky, but a (eventually fixable) firmware issue. On the other hand, I am concerned with the company's commitment to upgradability. Since they announced the 2nd generation motherboard some months back, the only way to get one has been with a brand new laptop around it.
Unlike desktops, where CPUs from different quality bins are sold at different price points (with different clock speeds), mobile CPUs are simply run at different voltages to compensate for quality differences. The resulting differences in power dissipation end up creating different temperature profiles, depending on which bin you happen to get.
Technology is a tool, neither intrinsically good nor evil. Unfortunately the tech industry has, as a whole, shown a stark disrespect for the needs or desires of individuals. Tech culture values monetization over individual autonomy, and that shows little sign of changing. Unfortunately, without a dramatic culture shift, it will continue to be the case that otherwise amazingly incredibly cool tech like this gets subverted to force more "personal" interactions.
The applications where these do well generally involve large text or video... AR apps like navigation, or watching TV while traveling.
Also worth noting: Many ACM publications will be cross-posted on ArXiV (https://arxiv.org) or faculty webpages. It's an open secret that many faculty will publish "preprint" versions of their articles there after the paper passes peer review, but before they sign any licensing agreement with a publisher.
For someone who already understands the syntax of a language (or at least the syntax of a related language), there's little to be gained from seeing what the code is doing. Take part of the Python example from the linked page: "The code defines a function called isPerfectSquare. This function takes an input of x, and calculates the square root of x. The function then returns whether or not x * x is equal to x.". This guides me through the code, line-by-line.
A more valuable description is "The function returns true if the input is the square of an integer". In other words, the more useful question is why the code exists. Good comments, explanations of code, function/variable names etc... focus on the overall objective of the code. For example: - What is the abstraction that the code is trying to capture? - What makes the problem that the algorithm is solving difficult/non-obvious? - What are the pre-conditions that a given segment of code assumes? - What post-conditions does the segment of code ensure?
Ocaml's standard library is amazing, and it has a great developer community, but at the end of the day Ocaml is its own thing. F# had virtually identical syntax, but put all of .NET at my fingertips. I was using it for UDFs in SQLServer, UIs with tables and plots, and a lot more. My brief flirtation with windows ended years ago, but F# remains one of the most positive parts of that experience.
The only check the TPM does when deciding whether to allow the key in one of its registers to be used is whether the stack is in a particular configuration. The TPM doesn't (and in fact can't) directly require passwords (since it has no direct line of communication to the user). However, the BIOS, bootloader, kernel, etc... can all be configured to mix user-provided information like a password into the hash they push into the TPM.
1. Using something not too dissimilar from blockchain/git repo hashes to attest to the the execution stack (BIOS, bootloader, kernel, userspace). 2. Providing cryptographic primitives that are only unlocked when the stack exactly matches a particular value.
It's a handy tool for avoiding spyware, as any change in the attestation chain gets immediately flagged. It is also, in principle, useful for tying DRM keys to a particular execution stack that's known to be trusted... although it's very worth noting that the TPM's threat model does not include an attacker having physical access to the hardware.
> - Municipal broadband expands the role of government. It's an extra program for the municipality to manage.
It requires physical infrastructure, and that physical infrastructure needs to reach people's houses. That, in turn requires the use of public resources (streets) and/or eminent domain. In short, government is already involved.
> - Municipal broadband is a government handout. It artificially lowers prices.
The level of infrastructure investment required makes it hard to justify new for-profit investment, especially if the area is already being served or isn't populated enough for the company to make a profit. As a result, internet access providers naturally tend towards being a monopoly, which in turn artificially increases prices.
> - Expanding government programs is a tax on residents, even if they don't benefit from broadband access.
I can see where this point is coming from, and it's not wrong. At this point, however, even those who don't directly benefit from internet access seem like they benefit indirectly. It's also worth noting that a lot of locales (mine included) already pump money into corporate broadband providers to entice them to build and maintain the infrastructure. In other words, the tax gets applied, regardless of whether it's a for-profit corporation reaping the benefits or not.
> - Municipal broadband is hostile to business. Companies cannot reasonably compete with a service that the government pumps money into.
Companies already can't compete with a service that requires enormous infrastructure investments and the use of government property.
Internet access (and most large-scale infrastructure) is different due to the heavy infrastructure investment required.
- It's hard to convince a for-profit organization to build out that sort of infrastructure in an area that isn't populated enough to allow the organization to make a profit.
- It's hard to convince a for-profit organization to build out a second set of infrastructure in an area that already has it, as increasing competition will lower prices and make it harder to make a profit on the investment.
- Building out multiple redundant infrastructures can also be a hassle for normal citizens. More closures due to maintenance/construction work, more use of eminent domain, more unsightly telephone poles, etc...
In short, Internet access tends towards being a monopoly. With that in mind...
- Artificially lowering prices is a good thing if it counters the natural tendency of a monopoly to push prices up. - Expanding the role of government is a bit of a non-argument, since
Can't speak for the other distros, but Mobian/Phosh has reached a point where it's usable as a primary phone. Tons of work from the community has brought battery lifetimes up from ~1 hour to the point where it lasts me the day under normal use. Firefox is usable, and most every piece of software I need has a workable counterpart.
That said, the experience is still quirky (think c.a. 2000 linux on desktops). Most things work, but the final mile still requires a decent amount of poking at config files and trawling wikis. Doable, but not everyone's cup of tea.
(Posted from a pinephone)
The difficulty with git in this use case is that it relies on the user to manually commit. If you try the analysis, and decide to throw the code away before you commit, too bad! There's no longer a record of it.
Vizier records everything. Every single change to the notebook, just like track changes in your word processor/spreadsheet of choice. Speaking from experience, it's really nice not to have to think about manually check-pointing... the history is just there.