I buried a Konami code in the ad integration JavaScript (no one wants to code review that) which flipped all the stories on the homepage for zombie invasion stories. The authors were all members of the dev and project manager teams. You can still Google it.
I did not get fired, for a couple reasons. One, I disabled all the ads, so there was no negative brand association. Two, we'd just launched a redesign and our homepage traffic skyrocketed from 45,000 views / day to 750,000 views a day. My personal highlight was receiving a mention on NPR morning edition.
My general manager "scolded" me in public, but privately was thrilled at the several hundred thousand dollars worth of free marketing. I figured I'd hang my hat up there.
https://www.forbes.com/sites/firewall/2010/06/15/newsweek-re...
> Instructor, Course Name, etc
> Ripley, Interstellar Ore Hauling
> Ripley, Terraforming 101
> Ripley, Criminal Justice Reform
> Ripley, Military Bio-Weapons Projects
It stayed up for a few years until my boss made me change it because one of the instructors got confused, complaining that they didn't teach any of these courses.
It did, then what the hell happened? :(
Like every other industry, the fun is all gone, and the bean-counters and moronic managers have taken control.
2. Why do I need your image hosting program?
2. You don't need it, but you want it
As I recall, Brian Valentine sent an email to the Windows division and basically said that easter eggs made the product look bad. Customers don't want to be patching their systems constantly (I was there circa 2000 so in the NT4/2000/XP era, so back when windows update was a website you visited, and the original NT4/2000 bug fix delivery mechanism was the service pack and various rollups) and then also hear it contained easter eggs for funsies.
Microsoft also licensed the source out to companies, governments, universities, etc and it wasn't a professional look. Easter eggs in games - that's fine. Easter eggs in your operating system, that licensees could see - not a good look when the previous product (NT4) didn't have a great stability reputation and Microsoft wanted to pursue businesses with new SKUs like Windows Enterprise, Datacenter, with features like clustering.
BV recognized programmers wanted to insert a little bit of credit so for Win2000 the easter egg replacement was either a link to a webpage (that listed the names of the Windows team members) or a rolling display of those members. Sorry I can't quite remember which it was... I think it was a link to a webpage to keep as much out of the OS as possible.
Remember this was around the time that Excel 97 had an easter egg flight simulator, Word 97 had a pinball game, and Windows NT 4 had one or two easter eggs maybe more (one was the opengl screensaver would 1% of the time draw a teapot at an intersection; the other was a scrolling list of windows team members that I don't remember how it was invoked. So due to this I'm 98% sure what he let into Win2000 was a webpage link). By now, the URL is probably long decayed.
(For the curious: Wikipedia has an article listing lots of old MSFT Easter eggs.)
Yeah, like _NSAKEY. Much planned. Very trustworthy. https://en.wikipedia.org/wiki/NSAKEY
The square could have been anything but I had a very cute picture of my toddler so I used a photo of them instead. So now somewhere in a database there are hundreds of reports with a picture of my kid in them :)
Now I work on systems that have more complexity in their I/O controllers than the devices I had started on, and no-one understands the full stack. When something goes wrong, the whimsy is the first thing that goes out the window in trying to find the root cause.
(To round out the anecdote, I’m a performance engineer on the younger side, so we’re not all bad :P)
And yet, the "expensive" hardware of now is cheaper than your single server from over a decade if you look at the whole picture... a lot of development trends are based on capitalism incentives:
- Outsourcing stuff like server hardware management to AWS is 1-3 FTEs less on your payroll, plus saving of datacenter related cost (climate control, UPS maintenance, Internet uplink, redundant equipment/spare parts)
- "DevOps" aka "let people who have never heard of Unix cobble together Docker containers and CI pipelines until it works Good Enough" is yet another saving of specialized expert staff (SysOp / SRE)
- "microservices" got popular because it's easier to onboard developers and treat them like disposable cogs if your work packages can be really small, with clearly defined interfaces
There's plenty of us old UNIX greybeards working in DevOps. And frankly in most fields of IT you're going to see your fair share of younger engineers because that's literally how life works: people get old and retire while younger people look for work. Moaning that kids don't know the tech they don't need to know is a little like trying to piss in the wind: you might get some short term relief but ultimately you're only going to soil yourself.
edit: It's also funny that you moan about AWS as outsourcing while saying "people don't remember Unix" yet Unix itself comes from a heritage of time sharing services which are the same basic principles of cloud computing.
If you're old enough you'll eventually see all trends in computing repeat themselves.
A bit graphic design, a bit of PHP, a bit of email management, MySQL, a "pay now" page imported from a payment provider, and they were making good money for a minimal startup cost. All the code written by one or two people, often some external help with the graphics, and sometimes the business concept was someone else's idea.
Obviously the services weren't scalable, they didn't have hundreds of millions of users, and they didn't operate globally.
But they didn't need to. And that's still true of many startups today.
A few of them sold up for large sums.
The "microservice" name just seems to be the modern way to make all forms of distributed RPC hipster fashionable.
Unix isn't that hard. And Docker containers and CI/CD pipelines open other cans of worms, and since no one seems to understand what is going on under the surface (because no one wants to touch Unix), they just add more monitoring tools and scaling.
But we suddenly need five times as many developers because 80% of the code is just dealing with interfaces and communication and handling race conditions and recovering from failed network calls.
I saw a script written by a devops employee where they zeroed out all the partitions when they added a new web server.
https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-init...
This is a HN trope that gets trotted out every time a subject like this comes up. It's gone from amusing cliché to just boring and false.
Yes, the hardware was simpler. But the knowledge wasn't.
For example, when I first started with ray tracing in the 1990's, you used something like Turbo Pascal and had to actually know and understand all of the math behind what you were doing. Today it's just #include some random other person's library and you're off to the races.
Today if a developer wants to display a new font, they just add it to the massive tire fire pile of other abstractions they've copied from the internet. Back in the supposedly "simpler" days, you plotted out a font on graph paper, then actually did the math of converting those pixels into bytes for storage and display. And did the extra math to find ways to do it in the most efficient way possible.
The knowledge has changed, but the amount of knowledge hasn't.
Things are much simpler now than they were then. That's why programmers today think it's OK to waste so much of their computing resources. With the supercomputer power we have in our pockets, this should be a golden age of computing, but instead we use that power to feed people's vanity and addictions.
side-effects were better understood and contained.
If that was true, then retro computer enthusiasts wouldn't still be discovering features and capabilities today.
Luckily, we quickly stopped doing that, but the idea that things were easier back then is because people learned from what we were doing. In 20 years, people will talk about how easy it was to make things in 2022.
The GP was talking about how much of the stack we don't know. Ie if something fails in an abstraction underneath what we develop in, then we're often fscked. And there are so many layers to the stack now that the simplicity of debugging the entire stack has gotten harder -- this is a true statement.
However you are talking about the barrier for entry in software development. It has gotten easy. This is also a true statement but it doesn't make the former statement untrue either.
By making it easier to write higher level code we end up obfuscating the lower layers. Which makes it harder to inspect the lower layers of the stack. So it's literally both simpler and more complex, depending on the problem.
> > side-effects were better understood and contained.
> If that was true, then retro computer enthusiasts wouldn't still be discovering features and capabilities today.
This is a grossly unfair statement because you make a claim for one side of the argument and, without comparing it to the other side (ie are we still discovering features and capabilities of modern systems?) draw a conclusion that the original statement is false.
So lets look at the other side of argument: in fact the reality is people are routinely finding optimizations in modern systems. For example you often see submissions on HN where hashing algorithms, JSON serialization, and such like have been sped up using ASM tricks on newer processors.
Another example is some of the recent Rust code released that outperforms their GNU counterparts.
It is also worth noting that modern hardware is fast so people generally optimize code for developer efficiency (a point you made yourself) rather than CPU efficiency. So fewer people are inclined to look for optimizations in the capabilities of the hardware. However once current gen becomes "retro", you might start seeing a shift were people are trying to squeeze more out of less.
I'm going to disagree, here. Things were as difficult as they ever have been since. Systems and side-effects are better understood only in hindsight.
Coding in assembly because higher-order language wasn't invented yet. Coding in a text editor because IDEs were not a thing. Searching linked lists because what's a data-base, not to mention SQL. Needing to keep things lean because 32kb was an ungodly waste.
In that light, things are easier than ever.
One can be both professional and whimsical. In fact, I'd argue that true mastery will only come with a sense of fun and interest in your craft.
Applying whimsy can be an engineering decision. Using 418 when any error code will do, for example, if it affects nothing else.
It's good that a developer has cursory knowledge of how those layers work (e.g. to avoid re-adding checks at the upper layers of something that is already guaranteed by the lower ones), but there's no need to be an expert at all them.
I'd say something like Docker containers, running a wasm engine, targeted by a lean library with a sane high-level programming language - either a santard-looking imperative language like Haxe, or some esoteric opinionated functional thingie like Julia or Elixir. (It could also be something like Vue, Angular or React, but those aren't exactly 'lean', being specialiced in working with the full browser DOM and web servers).
Each layer abstracts away the lower levels (virtualization & compartmentalization to run on any hardware, bytecode to run on any OS or browser engine...), allowing you to potentially use it without being tied to one specific implementation of that layer.
Higher layers provide increasingly more complex and powerful abstractions, with standardized code that's been created by experts in the field with efficiency in mind, and debugged through hundreds or thousands of client projects; making them likely more performant and robust than anything a single development team could ever build on their own (except for extremely limited domains run on dedicated hardware).
And ideally they have the plus side of working side-by-side with other applications or libraries, running in the same system without being engineered to work only with a single "official stack", allowing you to mix-and-match the best abstraction for each problem being solved, instead of forcing you into a single solution for all your software. That level of flexibility (plus the simplification of the layers below) is worth the runtime penalty imposed by several piled-up abstraction layers. That's why we don't code everything on assembly anymore.
But debugability was far harder, you could not do it remotely, and there was no stackoverflow etcetera to help you.
Example: Installed in another country is an embedded controller talking RS232 to devices. The controller is resetting, probably due to a watchdog timeout. The controller software uses a custom RTOS, with no spare hardware timers and it is hard to get logs back, which restricted in size to some kilobytes. You make educated guesses as to what is happening, but are failing. Many weeks of work later, you design your own process profiling technique using a hardware logic analyser and from that you find the root cause. Easily over a man-month of work.
Oh they do, it's just its more of a preference for some cute thing out of marketing. "Made with love" etc etc
Yea man, because most of us are just trying to get through the career part of our life to money and retire. Save your whimsy for your hobby projects. Nobody wants to debug production code with subtle easter egg behaviors.
Today, we could power his suggestions with a fleet of AIs running in over 200 Azure data centers around the globe.
Rumors that he would become self-aware are unsubstantiated.
The best reason to not add Easter Eggs is simply: they add unnecessary (albeit tiny) risk to a project. Technical risk and schedule risk. They are not part of the software's requirements, and they are likely going to be undocumented. Every line of code we add increases risk. Part of our jobs as developers is ensuring every line we add contributes more value than risk. Easter Eggs don't do this. Sorry to be Mr. Serious Raincloud, but please leave Easter Eggs for personal, non business-critical software.
OP, here. I don't completely disagree with you. As I said, there are always reasons to take them out, and almost always, those reasons are excellent.
A well-executed Easter egg says something good about the team and the project, though. A team that has the time, resources and capability to build something neat or cool or (pleasantly) surprising, is a team that is unstressed and competent.
To be clear, I'm not discussing something like adding a clown giggle to flight control systems. I'm talking about when there are two equivalent paths, neither objectively worse than the other, I prefer when the team follows the path that adds whimsy and fun to the project over when they decide boring is better.
A team that will at least consider adding it will inevitably be more efficient than a team that absolutely will not consider it because they fear extra work.
But over the very LONG TERM projects I see with Easter Eggs tend to have had developers who cared more about the project and were having fun, which leads to an overall higher code quality. (Your own experience may be different).
A perfect example from the article: the performance and memory impact on Windows startup due to loading the ASCII cats’ monospace font.
In most cases, in my experience, I can tell what generation an engineer comes from based on attitude to whimsy. Younger devs almost always don't like them. Too much effort, too much potential for trouble. Older devs, especially past retirement, almost always like them. This industry started with a sense of humor and fun.