GrumpyYoungMan

The least expensive option to start out with is to try out emulators running the ROMs (for home computers) or operating systems (for minicomputers like the PDP-11 and VAX that you mention and decide whether you really enjoy playing around with what are, by modern standards, very limited environments.

You will want to have a general idea of how a computer is internally structured but at a deeper level than is usually presented in popular material. I would suggest at least skimming through Tannenbaum's "Structured Computer Organization" (far more amenable to skimming than Patterson & Hennessy) and gleaning the high level concepts. Some may suggest Petzold's "Code" but I feel it's more aimed at a general audience than a technical audience. Others may suggest Nisan & Schocken's "The Elements of Computing Systems" used in their Nand2Tetris course but that's probably too low-level for what you want.

To get started with physical hardware, Ben Eater has videos for building a breadboarded computer based on the 6502 processor, which was used in the Apple II and Commodore 64: https://www.youtube.com/playlist?list=PLowKtXNTBypFbtuVMUVXN... that you can use to build your first computer. He also has parts kits available to make things easier: https://eater.net/6502. Some may suggest the videos he has for building an 8-bit computer from scratch (https://www.youtube.com/playlist?list=PLowKtXNTBypGqImE405J2...) but that also might be too low level for what you want.

From there, you'll probably understand enough to build breadboarded machines using other processors. Switching to an Intel 8088 which was used in the IBM PC will give you a 16-bit machine and the Motorola MC68000/MC68008 which was used in the early Macs, both of which are available in breadboardable DIP packages on eBay and elsewhere, will even give you a 32-bit machine to play around with.

> "Question: do elite institution degrees confer any addition to market value commensurate with their cost, or do they simply select for people who already have high market value?"

Speaking only for STEM, an elite STEM program gives the student access to a bigger variety of upperclassman courses; compare the available course list for a community college vs a large university and the difference is quite noticeable. The better programs also provide access to better equipment and advising; e.g., various University of California campuses have their own on-site chip fabrication labs. If the career trajectory you're planning benefits from those advanced courses, going to the better STEM programs is going to help tremendously. If not, well, they don't but that's hardly the institution's fault; they aren't choosing who to send your resume to, you are.

(As an aside, I use the word "access" very intentionally; educational institutions don't "confer" anything. Students get access to resources and opportunities and they choose which to take. It's entirely possible to do the minimum to fulfill requirements; for example, I chose easy courses to do the minimum fulfill my humanities requirements because it wasn't where my interests lay.)

Something like that's already been thought of: Alessandro Forin's eMIPS project a few years back developed a prototype processor with a small FPGA fabric directly embedded into the processor that allows for creating custom instructions per application, e.g. https://www.researchgate.net/publication/255563459_A_Framewo... among others. I don't think anything ever came of the idea; I imagine there's sharp limits on how much can fit into a CPU while still having decent performance.

> "The ability to modify the data paths in a set of general purpose processor components (e.g. register banks, caches, integer ALU, float ALU, vector ALU, pipeline lookahead, etc) for specific applications by modifying the microcode would be a real leap forward."

The latency and die cost of the connectivity for being able to rewire a "sea of execution units" is going to kill clock speed and performance.

> "Too bad win32 is such a finicky and verbose API that's painful to use for anything beyond the simplest of dialogs. I tried. The MSDN documentation doesn't quite cut it. TheOldNewThing by Raymond Chen is a must-read to get it right."

If it's helpful, I'd like to mention that Charles Petzold's "Programming Windows" has been pretty much the reference for writing Win32 apps since the '90s. (It's the same person that wrote "Code" and "The Annotated Turing".) You probably want the 5th edition as that's the last pure Win32 version; the 6th edition seems to be oriented towards C# based WinRT apps.

You could try Nystrom's "Crafting Interpreters" as an introduction but really you're asking about a topic that is usually covered in the final year of college because it has so much pre-requisite knowledge. You do need to know machine language for at least one processor architecture since that's the ultimate output that source code is being converted to. You also need to be pretty adept at data structures (often derided as useless knowledge by the HN pundits) because you're chopping up that source code into a structure amenable to conversion into machine code. (Ideally, you'd also want to know processor and machine architecture at a fairly detailed level because you can't really reason about performance without knowing the mechanisms by which machine language is actually processed and their constraints.) Only then are you at the point where it makes sense to talk about how the internals of a compiler is implemented.

There are inexpensive RFID tags with anti-counterfeiting features meant for retail goods, since that's become an increasing problem. They're primarily intended for retailer use since ordinary people don't have a RFID reader but since RFID readers are getting cheaper all the time, there is talk about consumers being able to authenticate their goods as well sometime in the future.

It's largely figurative anyway so it's still valid. But, if I were to change it, one thing that's dramatically different from the era of Heinlein's youth is that the world is a much smaller place that it once must have seemed. Global communication is trivial, cultures are blending together, travel to anywhere is within the reach of the general population, and the activities of civilization are great enough to affect the ecology of the planet as a whole. So the two new additions I'd add are "survive and thrive in any culture" and "understand civilizational trends", whether they be political, ecological, technological, or otherwise.

If JMeter or other off the shelf tools don't do what you need, writing your own load generator is the only other option. Fortunately, putting together a simple one is not that complicated.

I'd suggest the posts / talks from Brendan Gregg, a performance expert at Netflix, that have featured on HN: https://news.ycombinator.com/from?site=brendangregg.com. Most students will likely find themselves employed working on web / cloud systems and should find the sort of topics he covers to be valuable.

Some particularly interesting ones were:

"The Speed of Time" - https://news.ycombinator.com/item?id=28662945

"Meltdown Initial Performance Regressions" - https://news.ycombinator.com/item?id=16342665

"CPU Utilization is Wrong" - https://news.ycombinator.com/item?id=14301739

"Linux Load Averages: Solving the Mystery" - https://news.ycombinator.com/item?id=14959288

There are a few decent examples given by the Linus kernel devs on a LKML thread where an unfortunate soul wandered in and suggested that they refactor to get rid of GOTOs: https://lkml.org/lkml/2003/1/12/126

> "I will prefer to hide one or more of the inner loops inside of a function call."

That risks the additional unnecessary overhead of a function call, which can be expensive in a loop, and not all compilers are as good at optimizing as they should be.

> "The issue I think is that people today read "GOTO Considered Harmful" without really understanding the world at the time. ... Just because it was a bad idea to do everything with a GOTO 60 years ago shouldn't mean don't do some things with goto today."

Every time this comes up, I always encourage people to read an excellent analysis by David Tribble "Go To Statement Considered Harmful: A Retrospective" that goes over Dijkstra's essay line by line and explains what it means in a more modern context: http://david.tribble.com/text/goto.html It really should be required reading in CS programs.

I've used and still use goto in the few niches it makes sense to, primarily error handling and multi-level break in C/C++.

What's even worse is that, at the machine language level, condition and unconditional jumps are all that there are; we've all been using GOTOs constantly without even knowing it. :)

I'm more inclined to believe Collabedit's stats as a measure of language use in indsutry since it's commonly used for online interviews.

http://collabedit.com/programming-language-stats

See https://en.wikipedia.org/wiki/Direction_finding

If you wanted to do it cheaply and crudely, you at least need a portable spectrum analyzer that covers the frequency range you're investigating and a rubber ducky antenna that covers the frequency range you're investigating and then drive around watching for where the signal strength increases. (Make sure the antenna is outside the car since the metal of the body will interfere with reception of signals.)

Professional spectrum analyzers used for engineering are quite expensive (I'm told that Rigol's SAs are good for the price) but you might be able to get away with less expensive instruments like the RF Explorer or even an RTL-SDR and one of the software spectrum analyzer packages out there, assuming they cover the frequency range you're interested in. By definition, jamming needs to be powerful enough to drown out any competing signals so it should be obvious if jamming is occurring even to relatively low sensitivity instruments.

Well there's 1) The businesses that sell hardware are run by people whose expertise is hardware, not software and 2) the type of people who have the right combination of skills and inclination to write drivers are rare but also can earn a lot more doing other type of software (hardware margins aren't all all that high compared to software).

Previous discussion at https://news.ycombinator.com/item?id=9388751

FPGAs are entering FAANG level datacenters and some faint awareness is seeping into the biggest tech companies but I don't foresee it entering common use anytime soon. Good use cases are just too uncommon and people who know how to build logic designs for FPGA are also too uncommon for that to happen.

Along with the soundtrack, John Patrick Lowrie's amazing voice work also form some of my most vivid memories of the game. I still get goosebumps when I hear his narration of the opening cinematic: https://www.youtube.com/watch?v=k6mZZiI4ShQ

Total Annihilation was the first to have projectile physics for artillery and other weapons. One could actually have, for example, an artillery projectile in mid-flight accidentally collide with an aircraft.

[EDIT] Not mentioned on the BAR front page but also pioneered in TA was wreckage. Destroyed units left wreckage behind that had to be navigated around or fired upon to clear a path. Wreckage could also be scavenged to recover the material used to construct them, allowing the construction of more units. In the race to build enough infrastructure to overwhelm the enemy, this could be the difference between life and death.

IIRC while there are UHF RFID systems that can give rough physical locations, a clear line-of-sight between the reader and a UHF RFID tag is needed to get an adequate signal. If another book were on top of the book with a tag, that tag would probably not be detectable.

Personally I'd start with Corporate Confidential by Susan Dephillips. Skip the first chapter but pay attention to the rest. You aren't in academia anymore and this will give you some hints as to what's expected of you as your career progresses.

(As an aside, people here will suggest the other Corporate Confidential by Cynthia Shapiro but I do not recommend it. It does contain some nuggets of valid and useful information but a lot of it is presented in an excessively cynical and lurid way designed to appeal to the conspiracy theorist, something there's no shortage of on HN, or aren't applicable to the software profession. For example, Secret 29 "Your Values Are On Your Desk" particularly made me roll my eyes; nobody gives a hoot what's on your desk unless it's growing mold and the "...many internal promotions fail within the first year and are either fired or demoted..." also elicited a snort. Unless you're unlucky enough to be starting your career in a particularly toxic work environment, people are not going to be out to get you to that degree.)

If you haven't read DeMarco and Lister's Peopleware, that would also be an excellent choice.

The interesting bit here is the discussion of the considerations that go into designing hardware based random number generators and how their specific implementation on a resource constrained mobile device works.

Probably Military History Visualized's "Why Japan had NO Chance in WW2": https://www.youtube.com/watch?v=l9ag2x3CS9M . Go to the 12:30 mark for the the near-final ship totals.

I avoid VMs when benchmarking for the same reasons you cite. Benchmarking is difficult enough to get reproducible results without adding another variable to an already noisy process.

Over a lengthy career I've discovered that rule number 1 in the engineering world is "Nobody ever reads anything." This holds true even if they were supposed to beforehand and swore on a stack of bibles that they would.

No worries; good luck to you.

From the small bit I know about non-medical graduate admissions, the rigor of the program is a factor in graduate admissions but it only matters when comparing a candidate with good grades from a weak program and a candidate with equally good grades from a strong program. Again, it's all about the student and how well they can prove they learned the material, not about prestige.

If you really want a more in-depth answer to your question, go to https://academia.stackexchange.com/ and see what practicing academics say; this sort of question has surely been asked and answered many times. (I'd dig up some links for you but, not to be unkind, the very first thing you'd better get used to if you hope to reach graduate school is finding stuff out on your own given some hints.)

Kind of but at some point the rubber meets the road. You see a lot of comments on HN that say "Wow, this person came from a top university / FAANG and yet couldn't pass our interview or did badly on the job."

> "Does University Choice Matter?"

A better university matters only if you're able to take advantage of what it offers. While the core curriculum is more or less the same for all accredited colleges / universities, a better university gives you access to a larger selection of advanced courses, proportionately more well known instructors, and better labs and facilities. However, the pace of a better university is higher, the hours are much longer, and the competition from fellow students much stiffer than in high school; the transition can be very jarring. Only you know whether you're talented enough and able to put in the hours (the latter can substitute for the former to an extent) to do well enough as an undergrad to make it into a post-graduate program, but understand that the bar is generally pretty high.

> "BUT calling the gameplay boring with lots of running around is a fair statement. NieR:Replicant is worse."

Both Niers are RPGs after all, in terms of mechanics, and traditional RPGs are even duller (attack/defend/item/flee menu choices) but still manage to be enjoyable. From that standpoint, the bullet sponge nature of the enemies, being unable to defeat them until the player characters have leveled up enough, and backtracking is understandable.

Personally, I found the combat adequate (yes, even Nier:Gestalt) and sufficiently varied to keep things interesting.

> "...so that anyone with some computing background can build a processor, freely."

They could already do that. I designed and laid out in silicon a 32 bit processor as part of my undergraduate studies in computer engineering.