Ask HN: Old guys, what do you miss about development in the 70s, 80s, 90s, 00s? - <AUTHOR> Sorry for calling you old. <comment><USER3> On reflection, the thing I miss about web dev in the '90s is the low user expectations.

Because I was going to say I missed the simplicity of it all -- your front end was just HTML, no CSS (which didn't exist yet) and only sometimes a smidgen of Javascript for like light form validation; your back end was just a Perl script with CGI.pm running behind Apache that rendered that HTML.

No React, no flexbox, no REST API, no microservices, no Docker, no Kubernetes... but the reason it didn't need any of those things is because it had a terrible UI, didn't do all that much, and only needed to support trivial numbers of users whose modems were probably the main bottleneck anyway.

Trying to make modern users happy with '90s era tech would be impossible and deeply painful.

But it was nice, just for a while, to have a world where people were thrilled that even a super-basic web application was a thing that existed.

<comment><USER4> I still make websites this way because no-one told me to stop. They can be made responsive to things like smartphone browsers which incredibly minimal changes. No complaints so far.

<comment><USER5> What kind of sites do you make? I'd imagine that avoiding things like react is fine for a lot of sites that just need a bit of form input here and there and some nice styling, but that anything relatively big with interactive pieces would fairly quickly devolve into a difficult to maintain mess without components. I've sort of been trained to think that, though, as I was just starting development right before libraries like React started to get big. I remember reading cs books and learning about how important encapsulation and modularity was and then feeling like I wasn't really able to apply those concepts adequately in my really early web projects. React came along and seemed like the best answer. Do you do something different to organize code related to more complex frontend user interaction than forms/animations, or do you find that you just don't really need complex frontend user interaction for the websites you make?

<comment><USER4> Most of the things I've made are not public-facing. I just try to keep things simple. My sites generally require page loads more than the average single page application, but they have the advantage of loading faster and working in nearly any browser, even super old ones.

</comment></comment></comment></comment><comment><USER6> The Scrum bullshit didn't exist.

XP was a sane and useful thing before the sc(r)?umbags came along and shat in the Agile pool.

You could ctrl-u any web page, understand it, and do all the cool things you actually cared about yourself.

The web peaked before javascript f*cked it up completely.

Nobody played Matryoshka doll's with VM's and Containers, they did real work that mattered instead.

HTML and CSS standards and browser support for the standards were evolving semi-sensibly before M$ strangled it and the javascript "html5" spat on the grave.

Scheme/Lispy Lambda's just worked decades before these halfarsed modern languages came up with dozens of borked half- baked versions of it.

GUI's were an almighty colossal pain in the proverbial to write, so almost nobody did that and as a result were about 20 times more productive than they are today.

Threading implementations were borked, so nobody did that. They used processes and everything was much better. If you have any sense you will _still_ be using processes and not threads and your life still will be much better.

An, oh yes, pen plotters were fun to watch. Laser printers are absolutely wonderful.... but it's like the difference between a wood fire and panel heater... Which would you rather sit with a whisky in hand and just watch?

I might be an old curmudgeon, but I do have a very longer list of things that are much better than they were in the Bad Old Days if anyone cares.

Now GET OFF MY LAWN!

<comment><USER7>
      Laser printers are absolutely wonderful.

I got to operate IBM 3800 printers in the 1980s. The sight of a laser printer running at printing-press speed hour after hour, going through a 2' tall box of continuous-form paper in less than 20 minutes, was just _nuts_.

</comment></comment><comment><USER8> From the 80s I miss the variety of computer systems at the consumer level. Apple ][, C64, Tandy Model 3/4 and the CoCo, OS/9 and more. When it became clear everything would converge to x86, that made me sad. The world is just that much more boring without variety.

I miss programming in assembly. Slapping together frameworks with some sample code from Stack Overflow just doesn't provide the same mental satisfaction.

I miss interviewing in the 90s. No white board algorithm puzzles or such nonsense. Just a conversation to see if your interests matched the role and you're hired.

(I guess I don't miss the low salaries which were on par with any office workers in non-tech fields, nothing like today. But the good side was that everyone was in tech for the sheer love of it, not to make a buck.)

But what I truly miss (nostalgia aside) is when Silicon Valley used to be about technology. The big names in Silicon Valley were all actual technology companies: Sun, SGI, HP (the good original HP, not the ink maker). The product was the technology and the culture reflected that. Engineers were in charge and the goal was to make better technology.

Today the product is advertising and the goal is just to drive more eyeballs. Engineers have become commoditized and micromanaged (agile) by PMs who are driven by advertising goals. (PMs as we know them today did not exist.) Except for Apple, none of the big names today (FAANG) are tech companies anymore.

<comment><USER9> > Today the product is advertising and the goal is just to drive more > eyeballs. Engineers have become commoditized and micromanaged (agile) by PMs > who are driven by advertising goals. (PMs as we know them today did not > exist.) Except for Apple, none of the big names today (FAANG) are tech > companies anymore.

Does anyone know any tech companies or industries that aren't like this in the US?

I've been considering saying goodbye to the American market and going to Europe for a few years and see how things are there first hand. The one thing that would make me stay is the discovery of an industry or large company that doesn't micromanage and commoditize programmers.

</comment></comment><comment><USER10> Developers being far less critical of other developers.

We were much more positive in the olden days. Back in the 90s you could post an idea in a developer-oriented usenet group or discussion forum and get pretty decent feedback. If you do that today there's good chance you're going to either get nothing back or you're going to be flamed for using an "anti- pattern". People are far too quick to dismiss things now.

It's probably a function of how everything gets marked with a score now and every post is social proof, but it's quite annoying regardless.

<comment><USER3> You've got a very different memory of Usenet than I do.

<comment><USER7> Onion2k's experience mirrors mine.

There was a genteel, supportive quality of having a participation base comprised mostly of sincere, interested readers and posters. There were trolls even then, for sure, but they were few and were generally embarrassed into an inert mumbling.

I still remember fondly the debates in comp.lang.c about the first ANSI C standard proposals. Even Henry Spencer's rants against NOALIAS were entertaining.

And where user participation got unproductively unruly, moderated groups served well, like rec.humor.funny.

There was also an open, transparent _process_ for forking groups, generally along natural fracture lines, and for creating new subgroups.

What ultimately ruined Usenet (IMHO) was a falling signal-to-noise ratio, and not just because of spam. The opening of the AOL gateway and the resulting Eternal September proved to be mortal wounds.

</comment></comment></comment><comment><USER11> Speaking as someone who cut my teeth in the 80s and early 90s: I miss the elitism and exclusivity of it. Nowadays the internet has made it so any question can be answered within seconds, but back then you had to scrupulously acquire your information from magazines, Usenet discussions, and just plain experimenting with the code. As things currently stand, programming has become a commodity skill that anyone with a room temperature IQ can learn within a reasonably small time frame. Then, you get on StackExchange and start cobbling together your app from copypasta provided by other programmers.

Things have been dumbed down considerably.

<comment><USER12> Yeah. In the 90s I met almost no computer scientists. We all came from different backgrounds and got into programming because we were interested and liked it. Now we have a lot of people who chose it as a well-paying career. Nothing wrong with that but it's less fun.

<comment><USER6> I'm an applied mathematician that worked in those days with chemists, microbiologists, hydrologists, civil engineers, electronic engineers, physicists and almost every darn flavour of critter _except_ computer scientists.

Learnt a lot of interesting stuff.

Most of their code was utter shit to read and maintain... but then so is that from most recent comp sc graduates...

</comment></comment></comment><comment><USER4> That you could buy a book, read it, and then know literally everything about a particular system. And often that book came with the system.

<comment><USER13> Turbo Pascal came with reference manuals, but also with instructional books that taught you OO programming and Windows UI programming from scratch.

They must have been well-written; I didn't really have Internet access, so there was nowhere else to go if I got stuck. Though I was probably a much more determined learner back then.

<comment><USER14> Borland C++ came in a fucking chest of something like 40 800 page books. Books on OWL, books on the Win32 API, books on the Win16 API, lots of books.

</comment></comment></comment><comment><USER12> Worked in SW since early 90s. Back then you didn't have to think much about security and you could push things to the limit.

Also things were not as "professional". When I started out my boss told me to figure something out and I would report back weeks or months later. I had the time to make mistakes and learn from them. Today the young devs are often very micromanaged and have no freedom.

On the other hand we can do a lot of cool stuff today and it's amazing how much info is out there. But I think the 90s were more creative. Stuff like StackOverflow is great. Documentation was MUCH better in the 90s.

<comment><USER15> Yes, back in the day we used to consider thinking about security as sand in the gears of progress. A slog to get through with little payoff.

<comment><USER16> Sooooo.... like today?

</comment></comment></comment><comment><USER17> Despite this being an obvious honeypot to out the old people on HN, I'll bite. There's not much to miss about development practices of yore, except for the way better emphasis on documentation. I find most software developers today can't write worth a damn in their development practice. Requirements, specs, code comments, end user documentation, you name it. Really terrible bar. Perversely enough though, software developers today who blog can write amazing documentation on how to code. Go figure. OTOH, to view development in the 70's to the 00's from an emotional lens, what I miss the most was really living through the hockey stick of Moore's law. Everything was new and exciting until it got replaced 18 months later with a newer and more exciting thing. And back then, you were a sucker to bet against Moore's law. All it took to get a front row seat to this action was to code.

</comment><comment><USER4> I was tempted to write "computers were so slow and lacking in resources that you were forced to write efficient code". Because efficient code is good, right?

But I lived through that era and being _forced_ to write efficient code is a god-damn nightmare. There were so many ideas flying around that you simply couldn't do because the computing power just didn't exist.

Today people revere things like "vi" but when you were forced to use such basic utilities because your human/machine interface was a 300 baud modem, or even a paper teletype, life wasn't so good.

Nostalgia isn't what it used to be.

</comment><comment><USER18> I hope I don't qualify as "old", but I guess I've been programming since the early 00s...I miss the days when LAMP (+ XAMPP for local development) was more-or-less state-of-the-art for a website. PHP, despite its numerous deep flaws, really is a very pleasant way to write frontend code. I think what the web dev world needs is a modernized version of LAMP which:

* Is trivial to bootstrap

* Is totally serverless/scalable

* Can be run effectively for free with low levels of traffic, like an S3 static website

* Uses a non-broken PHP-like templating language (maybe jinja?)

* Uses Postgres instead of MySQL (ideally without infrastructure to manage, a la Aurora Serverless)

* Somehow intelligently figures out how to split between server-side and client-side rendering - ergo, you write templates like PHP and it seamlessly figures out bits that can be AJAX-ified to avoid full page-loads

If someone could just, like, make that, web development could be as fun as it was in the days of yore!

<comment><USER19> Django + stimulus

</comment></comment><comment><USER20> Late 90's here. There are two things I miss: 1\. Going to the book store and looking through the (mostly) O'Reilly books to see what there is to learn or what new technologies are coming out. 2\. Having a huge pile of 3.5" floppies (or even CDs) you are using to load the latest version of Visual studio or whatever and just imagining how much knowledge is contained in those. I think my copy of VC++ was something like 21 floppies.

</comment><comment><USER21> Elegant, tight, and efficient code mattered back in the days when a machine with a 20 MHz processor and 8 MB of RAM was considered a high-end workstation. You really had to understand what your hardware, your OS, and your compiler was doing in order to produce decent software.

Nowadays, such esoterica is relegated to the tiny niches of systems and embedded development.

<comment><USER22> My side project right now is flight control/readout software written in assembler for the C64 which will control a virtual spacecraft inside of my lua programmable 3d/physics libretro emulator front end.

I am really enjoying working inside of Turbo Macro Pro. It is an interesting challenge to make the assembly code efficient and easy to understand.

</comment></comment><comment><USER23> Turbo Pascal. Lightning fast compiler, snappy IDE, included graphic library, simple and beautiful language.

<comment><USER6> And every damn licence since then has been a frustration and tragic disappointment.

I was pro-closed source in Turbo Pascal days.... once the licences turned to complete shit I went pure opensource.

</comment></comment><comment><USER24> Main thing I miss is the lesser degree of abstraction in doing anything. If you wanted to build a simple app which just took one input and did a calculation and returned a result, there were multiple languages, but you didn't need a huge number of libraries, infrastructure, etc. to deploy it -- you just built the code, compiled it, and distributed a binary (and source, with a makefile). There was complexity crossplatform (even across unixes), but there was a period of time in the mid-90s/early 00s where "some form of linux or a BSD" was all I had to care about, and it was pretty easy.

Also, being able to trivially modify almost anything I used (because it was largely open source, and simple).

Lots of things were worse, but less abstraction was pretty nice.

</comment><comment><USER25> I miss building my own computer out of TTL chips.

I miss "the front panel" where I could single-step my program and read the octal / hex off the front panel lights.

I miss debugging my program with a plastic block and a wire to hand-punch patches into the binary paper tape.

I miss the "user manual" that had circuit diagrams as part of the documentation.

I miss doing "machine vision" on boxes of punched-card images.

I miss sitting "at the console" of an auditorium-sized "machine room" with a sea of DASD, watching the PSW flicker as the program counter changed.

I miss analog computers.

I miss coordinating 24 IBM Selectric consoles all "typing out" classical music (each one tapped out an orchestra instrument). Beethoven's fifth on selectrics....

I miss playing music by holding my radio next to the mainframe while my program was running, adjusting the program so it played a song.

I miss hand-designing a 16x16 multiply chip in MOS.

I miss programming plated-wire memory in binary switches to drive a Unimate robot.

I miss "scoring a complete copy" of the listing of Lisp 1.5 and reading the source code.

I miss running "the Hadoop algorithm" on a room full of punched card equipment (Google didn't invent it).

I miss "real programmers" who could solder. And could replace a failing memory address chip on your core memory board.

Good times.

But now I'm proving a computer algebra system correct. So it's all still good.

Rock on....

<comment><USER26> > I miss building my own computer out of TTL chips.

That sounds like an interesting project! Can you expand on it? When was this? How many TTL chips did it take? What other components did you use? What did you do with the end result?

<comment><USER27> You should check out Ben Eater's 8-bit computer from scratch.

[https://eater.net/8bit](https://eater.net/8bit)

There's even a kit for you to build one.

</comment></comment></comment><comment><USER28> Just the sense that we were on the cusp of some magical, new, civilization changing thing.

I don't get the same sense that stringing lines of code together can change the world, largely because, where it could, it mostly already has (I am not a believer in the latest wave of AI hype).

What we did used to be magic and was met with gasps and now, it's mostly just expected and complained about if it breaks :/

</comment><comment><USER29> > Sorry for calling you old.

Whippersnappers these days are so gosh darn polite.

Writing C code on a SPARCstation and Green Hills compiler/debugger as an undergrad in 1989, I got used to step-forward, _and step-back_ , in a GUI environment.

I had no idea that I'd never see that magic "step-back" button again, in C, C++, MFC, Java, Scala, or a litany of scripting languages and development environments.

Other people have touched on it, but you could be proficient in literally all the programming languages back then. There were less than 20. The later explosion of languages and techniques in common use can be overwhelming, but has stretched the spectrum available to our craft.

<comment><USER29> Oh, also: personal computers in the 80s booted into a BASIC prompt. It was a _terrible_ language to cut your teeth on, but it was there, right in front of you, and there were magazines and books (at the library and local book store, on dead trees), that taught fun things (like how to animate sprites, or set half your screen to graphics mode, or how to poke the midi controller into croaking out something beepy).

<comment><USER6> Or "poke" into the interpreter's ram region to do crazy things like shifting the string store to overlay the graphics ram and clearing the screen faster than any other technique by creating new blank strings and then poke the original values you peek'd out of it back.

<comment><USER29> Or spending afternoons typing in some game that was printed on the back of a magazine in assembly, and then poke 32768 and poof, game. Magic when you're 9 years old.

<comment><USER30> SYS 32768, not POKE 32768

As an aside, reading and understanding the entire disassembled "kernal" and BASIC rom for the C-64. All of it taking up less space than just about anything on just about any site nowadays - in that respect we took a wrong turn somewhere IMnsHO. Yes, storage is cheap and bandwidth abundant but the same is true for clean water yet nobody drinks 50 litres of the stuff per day 'just because it is cheap and abundant'...

</comment></comment></comment></comment></comment><comment><USER31> I miss the wonder and awe and naivety that all of this programming is leading to something better socially/politically or for lifestyle. In many ways it did. It also may have created more problems than it solved.

Also, I miss the joy of learning all the deep features and idiosyncrasies of a computer - its instruction set, I/O routines, timing and interrupt tricks, etc. These days I am focused more on Big Hairy Goals and complex systems. Fun of a different sort.

<comment><USER6> Are the Good Old days before computers became those things the secretary didn't quite know how to use.... it was downhill all the way from there.

</comment></comment><comment><USER32> There were very few ready-made frameworks and libraries to get things done, so it was fun writing those meta libraries that runs your business. Of course, purely from a business point of view, this is not ideal and is extremely wasteful. At the same time, it really helped me understand the systems that we use. Maybe that's why people survived without Stackoverflow :)

In comparison, modern software development is almost all about composing or stitching together a bunch of different services. There are other complexities around orchestration and breadth of the systems involved, but very rarely one goes deep into a particular technical problem.

After a really long time, I'm getting a kick out of working on a highly technical problem: an open source search engine from scratch ([https://github.com/typesense/typesense](https://github.com/typesense/typesense)). It has been deeply rewarding and definitely something that's missing in a typical web oriented software development career today.

</comment><comment><USER33> I miss job interviews (from both sides!) where a few people read the candidates' resumes, asked them deep and intelligent questions about what they had worked on in the past, and then made a hiring decision, without further quizzes, take-home projects, or probationary work-to-hire contracts.

<comment><USER12> I agree. My first interviews were like "You have no clue about C but you are good at FORTRAN and you are smart. No problem. You'll pick it up in a second. Read this book before you start.".

<comment><USER6> Ah, the good old, "Read this pile of books", call me when you done style of onboarding.

<comment><USER34> For my second programming job my manager handed me a pile of books and AFAICT that was the last thing he did before he resigned.

</comment></comment></comment></comment><comment><USER35> An office/room with only 1 or 2 developers (versus "open office spaces" now.)

My experience is that it was much better for concentration, creativity and productivity...

</comment><comment><USER36> I miss building everything from scratch, in assembly, because I could do it better than the libraries that shipped with the system.

I can _still_ do it better today, but the stack is so deep now, I just don't have the time.

Would I go back if I could? Nah.

Hacking is a blast, but never forget it is to achieve a greater purpose. A greater purpose for our software's users, for ourselves, and for for our subroutines.

Old hackers never die— we merely gosub without return.

</comment><comment><USER37> I miss dump reading on reams of green-bar paper.

The dump reading was done with a cardboard pamphlet that listed the machine instructions, arguments, address offsets.

You'd find the hex abend on the greenbar, mark it up with a pencil, and use the machine instructions to figure out what went wrong (and the record that caused it).

In my business (banking) this was done sometime around 2 a.m. after you got called back to work by the night operators.

Ah, the good old days.

<comment><USER7> My systems were core to business operations (manufacturing shop-order control) and always ran between 2-4 AM.

I quickly hardened the shit out of our interfaces so that we (a) wouldn't break and (b) had automatic workarounds for when feeding systems blew up. Oh, how my project leader loved me.

</comment></comment><comment><USER38> The ability to know a lot about a lot. And I'm not that old yet - I started my journey in the early 90s.

<comment><USER39> Like, because there are so many more unknowable levels of abstraction now? Hyper-specialization?

<comment><USER38> Among other things, yes.

For example: On an IBM PC, running DOS. You could know all there was to know about the BIOS, hardware ISRs, DOS ISRs, DMA, how a file system works, and maybe a bit about the graphics system, and you could make the machine do anything you wanted.

Today, if my kid wanted to learn all those things, I wouldn't even know where to tell him to start. You simply can't get that low (easily) anymore, or know that much about numerous subsystems. And the higher level stuff, like you say, is buried in layers of abstraction.

Of course, now we have an unprecedented access to cheap, powerful microcontrollers and SBCs, which make up for it to some degree - but it's still harder to translate that knowledge into something of perceived usefulness on a 'proper' computer.

<comment><USER6> It's all still down there somewhere....

"We build our computers the way we build our cities -- over time, without a plan, on top of ruins." Ellen Ullman

</comment></comment></comment></comment><comment><USER40> There was a lot less stuff, in general. Now you have libraries, protocols, umpteen different languages, paradigms, design patterns, IDEs, runtimes, platform after platform, etc.

I remember all I used to need was a C compiler and a task and basically alone I would be able to complete it with the standard stuff that came with the compiler.

</comment><comment><USER41> Perhaps the largest change over the forty years was the transition from software that shipped once every six months and had to last for years in production, to something that can ship every few minutes with a lifetime hours to a week.

During the era of shipped software (long cycle times) a hardware / software co-design model worked well to work out the customer requirements, dependencies, documentation, training materials, marketing, sales sheets, software, installation tools, and all manner of support modifications. Some of that cross-team communications takes more time and coordination than may be available in a two week sprint.

There were also the constraints of the release schedule burnt into everyones brain. So many things depended upon your shipping date that you dared not miss it. Sure, agile / scrum / whatever enables you to ship something a bit later, but there was nothing like the pressure cooker of everyone working as a team to make their delivery date. Requirements, in my rosy recollection, became very clear - things were in or out, not maybe.

Moving from large shipped software to web applications in 1999 offered any number of advantages, but it was quite difficult to keep the non-coders up to date with features and capabilities. Understanding doesn't always move at the same speed for all people.

What I'm going to say next may not be everyone's experience, but the two week sprint has started to seem like a convenient way to set and miss objectives; i.e., we can put it into the next sprint. Sure, I understand that planning is a black art in some cases, but always missing your commitments and making the same statement indicates, to me, that there's a problem with the absorption of the agile development model.

Product development and execution is a very hard process for all involved. Brooks had it wright, there are no silver bullets and the web seems to proliferate the belief that such things actually do exist.

I miss Tops-20 CMDJSYS sometimes. I don't miss VAX/VMS. SunOS was pretty darned scrappy at the beginning. Usenet prior to the 1994 Apocalypse On Line (AOL). I miss Fujitsu mechanical keyboards (so much noisy awesomeness). I miss having an office with two or three people, we had so much fun and worked so darned hard together. We remain terrific friends 30+ years later.

</comment><comment><USER34> I know it's kind of wrong, but I miss being part of a smaller community. I wasn't even one of the _really_ early pioneers, but when I started computing was still small enough that I could find common ground with just about any other programmer I met. Sure we had our specialization and even our disagreements, but there was probably _some_ overlap between what we each knew. We also got the chance to work on some genuinely new things. The early days of SMP or clustering were pretty cool. _Nobody_ really knew all the answers or thought they did. We were all experimenting. Now there are so many programmers doing so many different things that we might have _no_ shared knowledge, and so much of what most people do is reimplementing or papering over the flaws in some previous piece of software, layer upon layer like a giant midden. I'm exaggerating a bit, but it really does feel different in a way that makes me sad.

Since this is phrased as "old guys" I'll also add that I miss working with more women. Remember when I mentioned the early days of SMP? In those days we were still working closely with the people who were figuring out how to physically connect the pieces, keep caches coherent, what kinds of lock _instructions_ (let alone higher-level patterns) would be useful, etc. Hard core stuff, and maybe a third of the people I was working with were women. That's still not a majority, but it's down to less than half that in most teams I've been on for the past decade. Things have gotten worse, and that _really_ makes me sad. In so many ways, I feel this industry has been going backward.

</comment><comment><USER42> The simplicity of things. If you needed to write a 20 line shell script to solve a problem. That was fine. Today we argue about if tools are production ready. We take the simplest of problems and magnify it 20x. It will need a framework with 100% code coverage and 5,000 github stars, blah, blah, blah. All of a sudden you end up with 10k line of code, CI, CD and a team of 10 people for something 1 person could have rolled out in a day with a shell script.

</comment><comment><USER43> No DRM. No walled gardens. You could write code on your own computer without needing Apple's permission to code sign it.

<comment><USER34> It wasn't always so great across the board. Back in the late 80s or 90s I could write and distribute my own code for free. OTOH, for my day job developing network code on larger machines, we had to pay hefty licensing fees to get a decent compiler. Or debugger. Or libraries to do the most basic kinds of things. Corporate control hadn't come down to the smaller machines, but open source hadn't grown up to the larger ones either.

</comment></comment><comment><USER44> I miss being able to buy a complete 3rd party component for $400 that came with great docs and tech support.

Yeah, there are some excellent, well documented OSS libraries out there, but they are the minority and there's no one who feels obligated to help you if you need a small improvement or moderate bug, cause no one took money from you.

Imho, the trade-off isn't worth it (free but self serve support) for professional development.

</comment><comment><USER45> I miss developing in the 00s when I wasn't considered old yet.

<comment><USER46> Agree. I'm around students often. The way they treat me is pretty alienating. I liked the Sir Davos quote from GoT "the young treat us old people with respect because we're an uncomfortable reminder of the inevitable."

</comment></comment><comment><USER47> Moore's Law was pretty amazing while it was ruling the landscape.

The transition from monochrome monitors to color.

The explosion of new peripherals that did _new_ things, not just the same thing slightly better.

The first (consumer) hard disks.

For that matter, a computer that a _person_ could own, rather than a corporation, was an absolutely amazing shift. If you had an idea, you could try to make it a reality - not a reality for a company, but a reality that might become _your_ company. You could do that with just a bit of money, in your spare time (it would eat _all_ your spare time, though, and some more besides.)

I miss the 68000 series of chips. They were great to work on. (Others have said that the 32000 were even better, but I never worked on them.)

I miss SGI workstations. For their day, they were awesome.

<comment><USER34> > Others have said that the 32000 were even better, but I never worked on > them.

I worked on both. The NS32K had a more complete instruction set, but I wouldn't say that made it more fun. Then again, maybe I'm a bit weird. The chip I most enjoyed working on was the MC88K, which everyone else _hated_ because of its exposed pipeline. Part of me would like to tinker around with a 6809 or Z80 some day, not because I'd expect anything useful to come out of it but just because fitting within those constraints is a fun kind of puzzle for me.

</comment></comment><comment><USER48> FoxPro.

A real, ent-to-end development environment, with the ability to do the database, logic, forms and reports just 1 second after install. No package managers requiered!

My current dream is to build a spiritual successor ([http://tablam.org](http://tablam.org)) and doing it I start to appreciate how hard and how awesome it was. Also, the current me can't shake off the new ways (so, already diverted from Fox in a lot of ways) and must rely on imprecise memory of the past doing it. But still, I think a dbase-alike environment is surely missed....

</comment><comment><USER49> Learning web development via view-source

<comment><USER50> I'm voting this one up because I still hit view source out of habit knowing it will show me nothing. Gone are even the cute messages like "Hey, if you're looking here, we'd like to hire you!"

</comment></comment><comment><USER51> In the 1990s nobody thought I was crazy for writing CGI scripts in C.

(I still do it, but now people think I'm crazy.)

<comment><USER6> Or writing amazing CGI scripts in perl that did amazing things before I realized I had to maintain aforementioned perl scripts.

Turned to shit pretty rapidly, but for a day or three I was wondrously happy.

</comment></comment><comment><USER52> 70's and 80's here. Big fast printers. I know, who does massive code listings or memory dumps anymore? I feel that if I had one, I'd be using it all of the time, though.

<comment><USER7>
      massive code listings or memory dumps anymore?

When I started in mainframe programming, our organization had a license for a core dump formatting package that would do a lot of cross referencing for you and even break down COBOL into assembler on a line by line basis for you. Well thought out little things like that made a big difference.

</comment></comment><comment><USER53> From the early '90s.

I miss the simplicity of a 320x200x256 screen. Want to access the pixel at (0, 0)? $A000:0000.

I miss FIDONet.

I miss the big GOPHER network.

I miss the the variety of monthly ANSi packs.

I miss ACiD.

I miss the wonder and amazement of the demo scene.

I miss the community feel.

<comment><USER54> While not exactly as it was of course, FTN-style networks including FidoNet are still going and active, Gopher is still a thing, ANSI packs are still being released very regularly (ACiD folks are mostly Blocktronics at this point), demo scenes are still active, so on.

Hop on a Telnet/SSH BBS and check it out!

</comment></comment><comment><USER55> I guess the 2000s count, especially since I was working with 90s era technology when I learned to program. I miss QBasic. I don't think programming has been so much fun since. One of our projects was to make an animated Christmas card, with carols playing over the built-in sound. Later on, a friend and I worked on making a really stuttery, buggy version of Slime Volleyball. Everything you needed was built in, and the in-IDE documentation was great.

</comment><comment><USER56> For nostalgia purposes only: [http://cowboyprogramming.com/2010/06/03/1995-programming- on-...](http://cowboyprogramming.com/2010/06/03/1995-programming-on-the-sega- saturn/)

Things were much simpler back then. But, simple did mean easy. It meant you had to do every little thing manually from scratch.

</comment><comment><USER57> Goofing off while waiting for a compile to finish.

<comment><USER7> Getting analog lines in my office and/or the lab so I could rlogin around and fire off builds and tests from home so I could get an extra iteration or two in with minimal lag time.

</comment></comment><comment><USER58> As for web development in the 90s I'd be remiss to not mention live code editing in production ...

Just kidding, of course. It's a terribly bad practice. Don't do it.

However, there was something about the simplicity that came with it (in case everything went smoothly, that is) as well as the ability to make minor changes without having to go through a deployment pipeline.

</comment><comment><USER59> Solving problems together instead of finding the answer on Stack Overflow.

<comment><USER6> Actually had an office with a door you could close and a window you could open to actually think in.

And then walk down the corridor to the terminal room to turn thoughts into programs and/or ask the other guys or gals.

Strangely enough there were more ladies around in those days.

Miss that.

<comment><USER7>
      Actually had an office with a door you could close and a window you could open to actually think in.

Microsoft ran a radio recruitment ad campaign in SV in the late 80s with that exact theme! The narrator exclaimed how hirees would get "... an OFFICE! With a DOOR! That you can CLOSE! So you can THINK!"

</comment></comment></comment><comment><USER60> Late 90s, early 2000s... CSS Zen Garden, the amazing community of true forums/messageboards, IRC, learning from O'Reilly/Sams 24 hour/etc. books... so many memories...

Things were just more fun and about hacking. Now it's what's the next hipster JavaScript library.

<comment><USER61> Zen Garden still exists!

</comment></comment><comment><USER62> I miss how simple programs were in the 80s and 90s. I mean, they were a lot of work because there were no powerful libraries and you had to do almost everything from scratch. And then wait 30 minutes for the compiler each time you did a build. And it was way too easy to lose work before there were usable version-control systems (and even with the early ones, like CVS, it was easy to shoot yourself in the foot).

Stuff that was a major challenge back then, like rendering a polygon or keeping the state of an HTML form, is trivial to do today. I wish I would be paid to write early 90s programs with today's tools :)

</comment><comment><USER63> There was little or no evangelism for a particular language/framework/database/stack. People just trusted you to pick the right tools to get the project done, without feeling the need to insist you look at the latest flavour of the month thing out there.

But mostly, I miss the fact that 20+ years ago, programming was still considered a professional, white collar role that engendered respect from the entire organisation. Nowadays, I feel that most coders are lumped together with "support people" and are considered nothing more than replaceable factory line blue collar workers.

<comment><USER31> That's a very different experience than I remember. Macho culture dominated: assembler was the king, then C, then C++. LISP or Smalltalk or COBOL people hung out on their own and didn't talk to each other. Java was a joke usurper at first. Perl, python, ruby were toys. Etc.

IOW language advocacy and flavor of the month were rampant in the late 80s onwards from my POV.

These days at least there is enough community for all of the major languages and even the minor ones.

Also I find programmers get a lot more respect now than they did in the 80s and 90s. Programmers can make $300k+ USD at a top Bay Area company today, and starting salaries are well over $100k. Often they talk directly to users - <USER2> handlers or analysts in between to shield people from the "strange programmers". Attitudes have shifted. Though given your experience, I guess not uniformly.

</comment></comment><comment><USER64> Not having so many plug-n-play abstractions that you're so strongly encouraged to use to "not re-invent the wheel". The problem in my mind is that the abstractions leak all over the place, but we stop caring.

Pushing off compute to the browser because it's cheaper, nevermind the cost to non-powerhouse phones.

Avoid putting any thought into optimization because compute and memory is cheap. Nevermind that you'll have to do a complete re-write when a few dozen 600+ ms microservice responses results in 20 second page loads.

Store all the things! You might need them someday, after all. GDPR what?

I work with developers who think that DB migrations are "of the devil". As a result, they have pivoted to use the RDBMS as a rudimentary k/v store and create the relational data structures in memory. All they need to do is pull a few dozen GB of rows from the DB with every container restart.

So, yeah. I miss having fewer abstractions; having more constraints. The software seems somehow nicer through the CRT-colored lenses.

<comment><USER47> > Not having so many plug-n-play abstractions that you're so strongly > encouraged to use to "not re-invent the wheel".

 _Inventing_ the wheel, rather than re-inventing it. There was a lot more "doing something for the first time" and less "doing something for the Nth time, slightly differently".

(Or so it felt to me. But there was still a bunch of "doing what the mainframe people did a decade ago, but doing it badly". Still, it _felt_ different.)

</comment></comment><comment><USER65> XSLT

Edit: Well, to be precise, not XSLT per se -- but I'm missing a similar generic transformation DSL for structured data, ideally able to deal with any form of structured data like JSON, XML, CSV etc...

</comment><comment><USER66> I miss some of the old graphics solutions. Drawing something on the screen took a lot more work but it felt more real to me.

The prevalence of applications over webpages. Don't get me wrong the web has massive benefits in terms of standardization, distribution, and security but I miss the power and flexibility of traditional applications. And yes, I know they still exist but I'd say they're not the primary delivery mechanism of most user-facing software today.

</comment><comment><USER36> I miss when default username/password combos like admin/admin and root/"" would let you log in to a solid 5% of internet and Telenet (RIP) connected hosts.

<comment><USER6> And most .rhosts or /etc/hosts.equiv just had a single lonely '+' in them and nothing went wrong...

</comment></comment><comment><USER67> I miss working in my own office

</comment><comment><USER68> Burning and erasing UV EPROMs.

<comment><USER47> Wow, do I ever _not_ miss that!

</comment></comment><comment><USER69> working in an office with a door

</comment><comment><USER70> i miss the lack on distractors like fb,tw,whatsapp,et al i miss the time when people used to think instead of just search for the exact answer ;) do not misunderstand me, i'm not against it, i'm a php/js scripter 40yo guy that enjoys to copy paste Almost Everything but When I am not able to find the strightest answer, i start the thinking machine, i won't Almost Never ask that question on Facebook, hacker news, Twitter, stack overflow... I would prefer thinking than waiting for anyone else to answer my question. so, i miss the think first era.

</comment><comment><USER71> Not much, so much more is possible. But if Stack Overflow goes out of business, I quit. I do not miss trying to find obscure stupid things myself. The Internet is very good at making my time more valuable.

</comment><comment><USER72> I don't miss the assumption that all developers are "guys".

</comment><comment><USER73> Nothing

</comment><comment><USER74> 6502 machine language of the Apple II+ really helped get a mental picture of how computers work. Call -151 at the prompt then you're in. A manual listed what most ROM addresses did: move the audio speaker cone once by reading or writing anything to C030 (I think, or was it C080?), of course, 30 C0 syntax. 85 store the accumulator? Geez, it's been a long time. 1 MGhz 8-bit CPU, X and Y registers, an accumulator, only adding and subtracting commands except for shifting bytes left and right. No audio routines.

It was all very inefficient but what a way to learn!

It was probably like the 1930s and 1940s with radio: people really knew how it worked at the nitty gritty level and could friggn make an impromptu radio out of debris from a crashed army jeep (probably on youtube now).

That's civilization: layer upon layer upon layer of knowledge and advancements until we all roast the planet from our greed, driven by the 4% (the sociopaths).

</comment><comment><USER22> Just because I did development in the 2000s does not make me old.

</comment><comment><USER75> I had great times with .asp and ms access db ^^

</comment><comment><USER76> No leetcode puzzles in coding interviews!

</comment><comment><USER77> Hi, I posted this about mid 90's development in another thread:

""" Before about, 1996-- (I'm estimating)-- before network connectivity was the norm-- I understood how every processor in every system I dealt with worked. Two things happened in the mid to late 90s.

First-- an explosion of silicon. The days of understanding how the system worked, in its entirety, were over. I had a copy of "80386 systems designers guide", and I can't remember the name- but the Michael Abrash's guide to VGA video cards and a PC Interrupts were all that were needed to master computer architecture. If you were super fancy you understood the Pentium math extensions (whose names I cannot recall), that let you do a crossbar in a few cycles, and you understood how common chips like the 16550 worked, which is an addendum to PC Interrupts if I recall.

Second, and this is the key thing, technology started working AGAINST us. As complexity exploded, so did network connectivity. We had this era in which Operating Systems complexity exploded (win95), silicon complexity exploded, and connectivity exploded. The thing about connectivity is this-- that's when our computers went from isolated things to these things that are always online-- they started working against us. They could now talk to other computers, other people, and that changed computing fundamentally.

Computers went from these things that were our helpmates to our masters. This is what I lament the most. I don't miss bit-banging, assembly programming (well, a little). I fudging love Ruby/Python, as opposed to C++ being considered "High Level." I love that I can buy a computer for 35$ (RPI) that is fantastic. RPi's are so cheap I employ half a dozen just to run my 3d printers (yes I have a problem). But I do so much not miss being scared of my computer. Miss being scared of the ne5work. I miss the sense of wonder at what a computer could be or do. You have to understand technology as it exists now, is beyond my wildest dreams. I watched Star Trek TNG as a child and the devices we have now, legitimately have exceeded my wildest dreams. The simplest cell phone now has as much computational power as every computer combined at the time I graduated high school.

But, I do miss simplicity. So much so, I've been considering writing an NES or Sega game; I'm precisely 40 years old, and I've finally come to understand that art and constraints are intimately connected. That they press on each other, and neither is possible without each other.

I have so few restraints on modern systems that I... am constrained. I miss the constraints of my earlier years that were, in fact, my freedom. I miss software that shipped and worked on the first day. I, like everyone, miss my childhood. Because the universe is an explosion of complexity-- and when we look back, we will always feel like things were simpler-- because they god damned actually were.

"""

Also, I am old.

</comment><comment><USER78> Cubicles

<comment><USER79> I'd love to have a cubicle, honestly.

</comment></comment><comment><USER80> Some do, some don't. It's the same with every period and every group born in it. I grew up in the 1940s and can think of some things from that time that I miss, but I wouldn't go back for quids. Let's face it, we've never had it so good. These are the good old days.

A famous Australian (well, he was born in England but spent his life here) named Paddy Pallin nutshelled it. "The best place to be is here. The best time to be here is now."</comment>


Show HN: AtomicWrite: cross platform library for atomically writing data to disk - <AUTHOR> https://gitlab.com/jeffreyrogers27/AtomicWrite#readme <comment><USER2> Unfortunately, this technique is not guaranteed to work. Even if you write, flush then rename, the OS and disk may decide to apply these operations in a different order, breaking your guarantee.

A few years ago, I had to fix this behavior on Firefox, because it was actually causing data loss. The only techniques I found that seem to work are journaling and rolling backups + transparent recovery (which can still lose data, just one order of magnitude less often).

If you're interested, I wrote about the latter in this blog post: [https://dutherenverseauborddelatable.wordpress.com/2014/06/2...](https://dutherenverseauborddelatable.wordpress.com/2014/06/26/firefox- the-browser-that-has-your-backup/)

<comment><USER3> Ah, thankyou for fixing session restore. For years this was a really expensive (although useful) feature that caused huge disk write pressure. I used to have to move the Firefox directory to a ramdisk in order to have a usable system.

<comment><USER2> My pleasure :)

Other developers are currently working on fixing other aspects of Session Restore, including both performance issues and plugging other possible sources of data loss, but I'm not following this closely.

</comment></comment></comment><comment><USER4> Two issues:

Your technique potentially changes the owner, group, and protection bits of the file, which may come as an unwelcome surprise to anyone trying to use it as a drop-in replacement for directly over-writing the old file. (Worse, there seems to be no way to completely fix this in Unix-land as of the last time I looked back in the 90's, when we had to pull a feature in FrameMaker over this).

Also, be aware that (many? some?) disk controllers routinely lie about whether their internal caches are actually flushed to physical media, and there's no way for fsync to be 100% sure that the data has really made it all the way to the spinning platter of rust. Try testing your code by putting it in a loop and repeatedly pulling the power plug out of the wall, and see if you always end up with an uncorrupted file. (Yes, people do this sort of testing on highly fault-tolerant systems.)

<comment><USER5> Is there anything you can do in software (just thinking Unix) if the hardware lies to you about fsync? Or at the very least detect such devices, or are you at the mercy of simply testing the disk?

<comment><USER6> You're at the mercy of the disk.

The best you can do is assume that anyone who uses your application in production will have enterprise hardware, those (usually) don't lie about fsync (consumer hdd's are somewhat likely to do this)

I've also not yet run across a SSD that lies about fsync.

The disappointing thing is that most filesystems also blindly assume this. Ext4 is somewhat robust by design but I've heard of atleast one time where a (very) cheap consumer harddisk trashed any filesystem on crash, including ZFS to the point of becoming unmountable.

<comment><USER7> Did you mean _lie_ about fsync?

<comment><USER6> hmm, yes, thanks.

My spelling can go bad when I type a bit fast.

</comment></comment></comment></comment></comment><comment><USER8> This is a shockingly hard problem, which the technique still doesn't get right even if the hardware cooperates.

1) If the filename provided is just a filename, then dirname (and parent) may not work as expected. You ought run it through realpath first.

2) What if the parent's parent hasn't been flushed? You need to recurse all the way up to "/".

3) Extending support for other POSIX systems will be tricky. The Austin group (keepers of POSIX development) had trouble with this. Some systems consider using open() on a directory a complete sin (you _must_ use opendir()), some allow it read only but not with write, fsync() may require write permissions instead of just read, and opendir() may not produce an FD which you can ever convince fsync() to operate on (e.g. because no write permission). Indeed, the initial proposal from the Austin group was that all operations on directory entries should be atomic if the inode is also synced (which matches e.g. HPUX, one of the systems which strictly disallows any attempt at calling fsync() on a directory). Many other systems (Linux especially) obviously don't fit that model, it has some unpleasant performance implications, and overall no agreement was ever reached as to how to standardize it.

As for testing, you might look at "Torturing Databases for Fun and Profit" ([https://www.usenix.org/conference/osdi14/technical- sessions/...](https://www.usenix.org/conference/osdi14/technical- sessions/presentation/zheng_mai)) and "All File Systems Are Not Created Equal: On the Complexity of Crafting Crash-Consistent Applications" ([https://www.usenix.org/conference/osdi14/technical- sessions/...](https://www.usenix.org/conference/osdi14/technical- sessions/presentation/pillai)) for detailed approaches.

Good catch on Apple lying on fsync, btw. Not too many people know that one.

</comment><comment><USER9> The ITS operating system (at the MIT AI lab) had a system call called .RENWO -- "rename while open". Basically you could open a file, write into it (or read/write) and then in an atomic operation give it a new name and close it. So it was actually "atomic close and supercede"

It's really unfortunate the posix link() system call takes a pair of paths. It should really take an inode. Then you could open a temp file and immediately unlink it, and keep writing to it until you are finished (well, you can do this today as well). Then when you're done you could give it a name. If you crashed, you'd leave no detrietus behind.

<comment><USER10> Perhaps you could do this by creating a hardlink to /proc/$pid/fd/$n ?

EDIT: Doesn't look like it, gives EXDEV ("invalid cross-device link")

<comment><USER11> While I think the grandparent is right about POSIX not supporting this, I think this should be possible in Linux:

1\. Open the file with open(2), passing the O_TMPFILE flag. This creates a temporary, unnamed file. (As if you had opened it, then immediately unlinked it, but atomically.)

2\. Write to the file.

3\. Link the file into the filesystem with linkat(2), passing the AT_EMPTY_PATH flag (which tells linkat(2) to target a file descriptor that we pass it, not a path.)

(I'm not sure if step 3 helps in the case that you want to atomically replace the contents of an existing named file; I suspect that linkat(2) will error out because the file exists. Perhaps someday linkat(2) will grow a "atomic replace" flag.)

</comment></comment></comment><comment><USER12> This code is buggy because it assumes that a single write() will write out the entire file:

[https://gitlab.com/jeffreyrogers27/AtomicWrite/blob/8a40d050...](https://gitlab.com/jeffreyrogers27/AtomicWrite/blob/8a40d050341f5d35947f1b47e73e884e5d7509ef/AtomicWrite.cpp#L31-37)

In reality, write() may write a partial amount, so you need to loop and call write() again until the entire file has been written or write() returns an error.

<comment><AUTHOR> Thanks, you're right. I'll fix this.

</comment></comment><comment><USER13> This library does not come even close to doing what it claims to. This is excusable because it is actually a very difficult problem with no simple solution. Depending on your hardware and software, it may have no guaranteed solution at all.

Let's start with the fact that modern disc controllers cache megabytes of data and there exists no way to force them to write it out. There exist a few ways to suggest this. Some will listen, some will lie. SSDs even worse in this respect, they cache hundreds of megabytes, and while they're doing garbage collection, even more data may be touched and modified. Depending on how good their algorithms are, you may lose the data that you are writing if they're powered off suddenly, or entirely unrelated other data, or perhaps a little of each. There is no standard way to tell an SSD to flush its data to actual Flash either, of course. In fact, depending the the logic in the FTL in use, this may not even be possible to do quickly (say, you discover a few bad blocks during garbage collection and need to relocate a lot of data suddenly). This changes even across firmware updates.

And then we arrive at modern file systems. The default mount options generally only sync metadata to disc no matter how many times you call the sync system call. All the dirty pages containing actual file data will be written whenever the system damn well feels like it. And of course, as mentioned above, they're only written to the volatile RAM inside the disk controller.

This is actually an insanely complicated problem. If you want to see how it is solved professionally, take a look at a databases. People who work on sqlite spent countless hundreds of hours making stuff like this work reliably, or break in ways that are predictable and recoverable. Generally this involves extreme amounts of journaling, sometimes multiple levels of journals. Oftentimes there is a whole lot of os-specific quirks handling to fix the differences between what the OSs promise functions do and the reality.

This is actually why, if you ever start needing to "write things reliably", or "store more than a few of something in a file, and update it", and you can spare the code size, just use sqlite for your storage. Because there's a whole lot of problems you're going to hit that they have already solved for you.

</comment><comment><USER14> The pain I had with atomic writing on Windows is that Windows rename does _not_ behave like the POSIX standard:

[https://msdn.microsoft.com/en- us/library/zw5t957f.aspx](https://msdn.microsoft.com/en- us/library/zw5t957f.aspx)

          "The old name must be the path of an existing
           file or directory. The new name must not be
           the name of an existing file or directory."

I ended up having to use ReplaceFile and rename if ReplaceFile failed:

        ReplaceFile(tmpFileName, fileName, NULL,
                    REPLACEFILE_IGNORE_ACL_ERRORS, NULL, NULL) == 0 &&
        rename(tmpFileName, fileName);

[https://msdn.microsoft.com/en- us/library/windows/desktop/aa3...](https://msdn.microsoft.com/en- us/library/windows/desktop/aa365512\(v=vs.85\).aspx)

Why Windows why?

<comment><USER15> I usually don't defend Windows, but, rename not overwriting (without an argument) seems safer as a low level API, no? Given it takes a 2 line helper to achieve the same thing in C++ [1], doesn't seem that bad.

[1] [https://gitlab.com/jeffreyrogers27/AtomicWrite/blob/master/A...](https://gitlab.com/jeffreyrogers27/AtomicWrite/blob/master/AtomicWrite.cpp#L144)

<comment><USER16> Safety is usually not a design goal for low level APIs. You rather want it to be minimal, functions to be orthogonal, clean abstractions and only promise necessary semantics.

And this might be already the reason. Win32 is geared towards the broad range of developers whereas Unix comes more from systems thinking.

</comment></comment></comment><comment><USER17> As another poster said - syncing is unreliable.

On Windows even if you use native API to open a file in a write-through mode with no caching (FILE_FLAG_WRITE_THROUGH | FILE_FLAG_NO_BUFFERING), you will still end up with zero-filled files if the machine is power cycled or blue- screened in the right moment. Disk controllers cache aggressively and there's not much an OS can do about it.

</comment><comment><USER18> A reminder that Reiser4 exists and is still getting updated. Fast, stable, and most of all: atomic (only one core though).

You'll need to patch your kernel[0] and install the mkfs.resier* util[1]. Take a look at this Gentoo-forums tweaks post[2] for troubleshooting and performance tweaks. If you find reiser is lagging, your filesystem was likely built incorrectly and you'll need to run a simple

         fsck.reiser4 -y --fix --build-fs --build-sb

on your partition and it should be fixed. I only made the switch recently because Ext4 doesn't have intelligent inode allocation and drops the ball at 1mil files.

[0][https://sourceforge.net/projects/reiser4/files/reiser4-for-l...](https://sourceforge.net/projects/reiser4/files/reiser4-for- linux-4.x/)

[1][https://sourceforge.net/projects/reiser4/files/reiser4-utils...](https://sourceforge.net/projects/reiser4/files/reiser4-utils/reiser4progs/)

[2][https://forums.gentoo.org/viewtopic-t-707465-postdays-0-post...](https://forums.gentoo.org/viewtopic-t-707465-postdays-0-postorder- asc-start-0.html?sid=253eb8003e3ad8a80066f4d24d634c4a)

</comment><comment><USER19> there has a lot of work on this at U. Wisconsin, namely starting with: [https://www.usenix.org/system/files/conference/osdi14/osdi14...](https://www.usenix.org/system/files/conference/osdi14/osdi14-paper- pillai.pdf) The testing framework there is something you need to help establish confidence that what you are doing actually works...

</comment><comment><USER20> I'd be very interested in any way that would let me (quickly) write small changes to large files atomically, on Windows. The naive solution is to copy the original to a temp file, then proceed as in this library (write then atomic rename).

I'm thinking there may exist some lower level magic api with e.g CoW pages that lets the caller appear to copy the original without actually doing it? "Shadow copy" or similar?

<comment><USER21> There's something called Transactional NTFS, which does exactly what you want. But Microsoft decided to deprecate it in favor of other (and IMO far less elegant) options.

<comment><USER22> That's a funny one. The kernel changes they needed to make in order to support transactional stuff were pervasive, and it's used extensively under the covers. The MSDN commentary makes it sound like they're going to completely pull the functionality one day, which is misleading.

</comment></comment></comment><comment><USER23> I'm curious why it writes the whole file... Can't you do something like:

          if rollback log exists
             recover
          create log
          for each write(),
             write old contents of region to log (along w/ location)
          sync log
          for each write(),
             write new bits
          sync db file
          remove(log)

<comment><AUTHOR> That is probably a better approach for large files. My initial use case was an application that would write an encrypted file containing passwords to disk. The files are relatively small, so that method didn't seem worth the additional complexity of something like what you describe. I believe sqlite does something similar at least in some configurations.

I might add something like this in the future.

</comment></comment><comment> dis-sys The title is pretty misleading, as already clearly mentioned by the author, the library is all about atomically _creating_ a file with specified content on disk, it is not about how to atomically append/update/delete files on disk.

<comment><AUTHOR> That's a much harder problem and I don't think you can do it portably. In fact, I'm not sure of any filesystem that can make those guarantees.

</comment></comment><comment><USER24> At our work where we needed atomic write in Java, I believe we are using undocumented use of the file API to force the flush. (It's a top hit through stackoverflow)

</comment><comment><USER25> Interesting. I wonder how much effort it would take to make this asynchronous as well. I can think of a few situations where this could be pretty useful.

</comment><comment><USER26> I wouldn't touch this problem with a 10 foot pole. Use SQLite and stop worrying about it.

<comment><AUTHOR> I wrote this because I have an application that requires this but where SQLite isn't suitable.

</comment></comment><comment><USER27> Windows implementation misses TxN, which makes it pointless.

<comment><USER28> TxN? Do you mean Transactional NTFS (which is shortened to TxF in the documentation). And isn't that deprecated with a warning that it might not exist in future Windows versions?</comment></comment>


Musiqli - <AUTHOR> https://musiqli.com/

<comment><AUTHOR> Musiqli is a digital resource hub for classical musicians.

Collaboration is the lifeblood of music. For too long, finding the right musicians to work with has been a hit and miss process, and valuable creative time has been wasted on synchronising diaries and sharing resources.

Musiqli brings musicians together by offering a set of tools and services that take the hassle out of organisation, and by precisely matching musicians with other musicians and groups.

We're creating an online community that actively promotes the sharing of skills and knowledge, so you can get on with what you do best: making and performing music</comment>


Ask HN: Should I sue public company? - <AUTHOR> I have a situation now:
My company was acquired a couple of years ago and by contract with an acquirer they have to pay now the rest of the money.
Acquirer now saying that they don't want to pay and if you wish - you can go and sue us, but in meantime, we are a good company and we can pay you 1/3 of the money.
My lawyer told me that I have 99% of winning this case, but I will spend about 14-18 months on that case, + costs for the lawyers will huge and I'm not sure that I can afford it now.
Need a suggestion <comment><USER2> This is something you should discuss with your lawyer. We almost certainly don't have the full picture of the situation or grasp of any of the nuances.

With that being said, this seems like a fairly straightforward cost-benefit analysis relative to your personal finances and life plans in the next 2 years (getting married? moving? etc). Can you afford the time/cost? Do you have the emotional energy to do it over the span of 24 months?

If I had the time/energy to do it, I think I'd definitely give it a shot. I'd want revenge and to ensure they don't do it to anyone else ever again.

</comment><comment><USER3> Someone else commented: Another thing to consider is that if they get a letter from a lawyer, they may just pay up. I'd start there and see what happens.

Exactly this. Acquirer doesn't want a lengthy case either. A lawyer will guide you to start with a demand for the full amount, else a suit will be filed. The Acquirer will probably counter with an offer and you guys can start a negotiation to end it quickly.

I am not a lawyer and this is not official legal advice.

</comment><comment><USER4> I would think that you would have no legal fees if you lose, and the fees would be less than 2/3 of the money.

If you let them do this, they will continue to behave this way. (if you win, doesn't mean they will change)

But, how do you want to do business and carry yourself.

Another thing to consider is that if they get a letter from a lawyer, they may just pay up. I'd start there and see what happens.

</comment><comment><USER5> As a public company, don't they have to disclose lawsuits like this?</comment>


Palm makes eyes at possible purchasers - <AUTHOR> http://www.theregister.co.uk/2010/04/12/palm_purchase/ <comment><USER2> a list of companies that could buy palm

* Dell, Sony, HTC, etc.. -- Have mobile devices, but this could give them an edge.

* ASUS, Abit, etc.... -- All make hardware and could use a nice mobile platform.

* Amazon, Barns and Noble -- both make eReaders that could be decimated by the iPad, Palm's Web OS could give them the engineering talent along side a great OS to create a new Mobile media device.

* nVidia - if nVidia had a platform like WebOS, they could ensure a rockstar platform for their mobile chips.

* AMD - I don't think AMD has the cash to buy palm.

* IBM - Could be interesting, IBM has cash, and they don't have a mobile plan. This may be reason for IBM to go after a mobile leader.

* Oracle - Since Oracle has acquired Sun, MySQL, and .... OpenOffice by default. It might be interesting to see what this Tech Giant could do in the Mobile Enterprise Space.

* Google - Could buy Palm to strengthen it's position against Apple, and could port Palm's intellectual property to the Android OS.

* Nintendo - Hmmm, this could be interesting, as I think the companies would culturally work well together.

* Microsoft - Yeah, WM7 +++ MS could somehow make windows mobile better, or better arm it's lawyers against Apple. Can you imagine the MS Palm Courier?</comment>


Tactical Nuclear Weapons in Southeast Asia (1954) [pdf] - <AUTHOR> http://nautilus.org/wp-content/uploads/2012/09/tactical_nukes_vietnam.pdf <comment><USER2> The headline says 1954, but that is a misreading of the cover page. The report appears to have been authorized by the Atomic Energy Act of 1954 but its publication date is listed on the cover page is 1967.

<comment><USER3> Yes, the report refers to the (US) Vietnam War and the Rolling Thunder campaign, which took place in the 1960s. Can the OP change the title to refer to 1967?

</comment></comment><comment><USER4> Interesting document. TL,DR: even dozens or hundreds of nuclear weapons used on a recurring basis are not a guaranteed way, or even an especially effective way, to counter guerillas operating on their home turf. US forces concentrated in 14 individual bases would have been far more vulnerable to use of Soviet- or Chinese-sponsored nuclear weapons than the enemy troops would have been to our own.

Additionally, the successful use of tactical nukes against US troops would have encouraged both third-world countries and insurgent forces all over the world to ally themselves with the Communists to obtain weapons of their own, which was literally the opposite of what we were supposedly trying to accomplish in Viet Nam.

The conclusion, as usual, is that the only way to win this particular game is not to play it.

<comment><USER5> "the successful use of tactical nukes against US troops would have encouraged both third-world countries and insurgent forces all over the world to ally themselves with the Communists to obtain weapons of their own,"

Such countries are well aware that these weapons exist, and that the Russians can field them anyhow.

The more likely response against anyone, at any time using nukes of any size against the US is that they 'wake the dragon' in a way bigger than Pearl Harbour. Remember the 'fear' of nukes is quite substantial, even if tactical nukes are a small deal, the concern is big. It would have been 9/11 x 10.

And the world would be different today probably.

</comment></comment><comment><USER6> It's mentioned that India's nuclear program has the capability of producing 500 bombs in the next 10 years.

Was the US already aware of India's nuclear capability?

<comment><USER7> They say the civilian nuclear power program would produce materials that could be used to make up to 500 bombs. That's a known risk of "civilian" programs, which is why Israel bombed Iraq's reactor and has threatened to do the same to Iran.

In any case, the bomb project was also probably riddled with CIA and KGB agents (at least that used to be the rumor back in the day).

<comment><USER6> >> _the bomb project was also probably riddled with CIA and KGB agents_

You mean to say India's bomb project was riddled with CIA and KGB agents?

<comment><USER8> Every bomb program is targeted by every intel agency. A few always get through. It isnt always a bad thing. Mutual knowledge is a cornerstone of deterance.

<comment><USER6> I was about to pitch Operation Shakti [https://en.m.wikipedia.org/wiki/Pokhran- II](https://en.m.wikipedia.org/wiki/Pokhran-II) as the one that got through.

</comment></comment></comment></comment></comment><comment><USER9> Looks like Freeman Dyson was a co author. Interesting document — it challenges the notion (which is not realistic, but is still believed) that if the US had just been more ruthless, it could have bombed the North Vietnamese sufficiently to "win" the war.

<comment><USER10> Just imagine how the world would have reacted if the USSR had used tac nukes in Afghanistan to "win" its war there.</comment></comment>


Show HN: A prototype for an HTML5 multiplayer game - <AUTHOR> https://tibibi.herokuapp.com/ <comment><AUTHOR> This is a prototype for an HTML5 multiplayer game I'm making. This prototype is actually defunct as I'm now starting up a new game--a 3D multiplayer game, in fact. The data and experienced gained from the development of this prototype will be used for the success of the 3D multiplayer game.

Some of the technical aspects:

Initially, socket.io was used to establish real-time communication between the client and the server, but the ws WebSocket library was then migrated to.

A client-server protocol of binary data is primarily used to share game state between the clients and the server.

On the client-side, the Phaser game development framework is used to render the game and perform client-side collision detection. On the server-side, a small and simple custom made game headless game engine made with Node.js is used to manage game state and also distribute the game state to the connected game clients.

How to play:

To move, use the WASD keys.

To shoot, aim with the mouse and press the left mouse button in the direction that you want to shoot in.

You can shoot and eliminate other connected players, making them respawn after five seconds.</comment>


Show HN: FlowNote – Another Markdown Note App - <AUTHOR> https://www.flownote.app/ <comment><AUTHOR> Hello! For the past six months I've been developing a simple note app to aid my workflow. Recently, I've spent a lot of time at work doing architecture work and a lot of that time has been researching new technologies and unfortunately this hasn't left me a lot of time write code. This application has served the purpose of allowing me to continue to write some code on the side and build out a simple and powerful tool to share the research I've been working on with my team.

There really isn't anything special about the application when it comes to notes apps, it uses a pretty generic flavor of markdown for writing and formatting your notes, it allows you to make any of your notes public and provide people with a share link to read your content, it also encrypts the data at a column level to add an extra layer of security, it has a feature to add a little more structure to your notes by having multiple input boxes on a single note, and its also surprisingly fast!

The app is currently free to use (very much in beta) and is still lacking some features but I wanted to get it out there and get some feedback from the community. Let me know what you think! Thanks!

</comment><comment><USER2> looks cool. heavily github-inspired design.

i'd remove the "beta" tag from the navbar logo on log in/sign up.

<comment><AUTHOR> Yeah, I used the Github design system called Primer for most of my views, I like the simplicity of it and it feels natural since I spend so much time in Github. And that's probably a good idea, thanks!</comment></comment>


Ask HN: How can I make sure my phone isn't listening to me? - <AUTHOR> As well as other devices. I've unplugged my google home, but like many people, I have several devices with cameras and microphones in my house. What can I do to ensure they're not recording or listening to me? <comment><USER2> [https://arambartholl.com/blog/deafen-your-phone-how-to- make-...](https://arambartholl.com/blog/deafen-your-phone-how-to-make-sure- your-phone-is-not-listening-on-you/)

</comment><comment><USER3> I think the answer here depends on how much trust you have for the different levels of tech in your phone. If you don't trust anything, the answer is install a hardware switch for the microphone or cover it with a sound blocker when you're not talking (just like if you don't trust your laptop's camera, put a piece of tape on it). If you trust the hardware, but not the OS, install something like Lineage to replace stock. If you trust the OS, but not the apps, uninstall any app that might have access to the microphone (especially "bad actor" apps like Facebook) and only use web versions.

</comment><comment><USER4> Hey man. I think you know the answer already - there is no way to make sure about it. It's the same questions as "How can I make sure that my software is not hackable". But are you going to live without any digital devices, probably not. Change your router password periodically, unplug devices when you don't use them, put tapes on cameras or deactivate them if not needed...I hope we can all own our own privacy. Unfortunately, it's impossible if you want to live in the modern society.

</comment><comment><USER5> You can't.

If your baseband is pwnd -- and it is to some definition of pwned. The unit can appear off and still be recording.

Citation: The NSA document leaks.

</comment><comment><USER6> Just a thought, is there a way to capture all out-going traffic from one's phone at least when it's not been used?

<comment><USER7> You can get SIMs from carriers that allow you to forward the traffic to a VPN server of your choice (often used in enterprise to make mobile devices part of the internal network without a battery-consuming on-device VPN client).

If you're in the UK a company called Andrews & Arnold (no affiliation besides being a longtime customer & reseller) provides those out of the box with no setup fees and an "okay" price per megabyte of data. Otherwise get in touch with carriers but I think most of them would have a setup fee.</comment></comment>


Ask HN: Project ideas for PhD student moving to industry - <AUTHOR> Hello,
I'm finishing my PhD in CS in a couple of months and I'm applying for software engineering jobs with no luck.
I get rejected from entry level jobs for being overqualified, and from more senior jobs for lacking industrial experience.
I know C++, C, Python, a lot of algorithms and some ML, some data mining.
I pass most of the hackerrank style interviews, but then I get rejections for not having enough experience.
I have two months of writing and some other boring stuff. I can dedicate 10 hours a week for improving myself for job applications.
Any ideas? Should I do a programming project?
Any suggestions? I have interested in Algorithms, security, storage systems, ML, and DM.
I appreciate your help. <comment><USER2> Where are you located?

You can apply to R&D roles (search for R&D engineer, research software engineer, R&D software specialist and similar titles) which are essentially software engineering roles that require grad school.

A good idea may also be to pick a subfield that traditionally hires more educated people (science or engineering or chemistry software hires from that pool because the clients tend to be in academia).

In a given city most of the PhD-friendly industry jobs are staffed by people who still regularly see your professors at happy hour. Have you talked to your professors and alumni of your program if they know anybody's who's in industry now? Look up on LinkedIn where the people from your lab ended up. You can probably get some of these people to give you an interview that's not biased against your specific experience.

<comment><AUTHOR> In the middle east.

They all continued to work in academia as postdocs. I don't want to go in that path. Especially that my most recent work was in a field I don't enjoy, but I had to do it because my previous adviser had to leave university and that was the only option or else I would have wasted the previous years effort in vain.

I have lots of theoritical experience in many areas and I just need to start in a first job. And from there it would be easy. As I will be able to say I have actual industrial experience.

I want a software engineering job. I even apply for entry level jobs and I get rejected. I even got rejected several times for internships.

<comment><USER2> Do you get to the interview, or they don't even reply to your resume? Because if you get interviews you need interview practice not projects.

Assuming you do have, like, school projects, and your PhD project includes programming. Otherwise you do need projects. For C++ a good way to have projects is to talk to PhD students in other fields (physics and bio are good) and ask if they need help with their computation and modeling. Listen to them a lot as they often already use software for most important things but may have need of e.g. quickly indexing text files or targeted data visualizations. In industry, we like hearing about collaborative projects.

<comment><AUTHOR> I get some interviews. If applied for 100 positions: around 50% don't reply. around 40% reject me. Part of that could be because if visa sponsorship.

Some reply and I get interviewed. In most of the cases, I do very well in their technical interview. Then they would say, we are looking for a senior software engineer.

In two interviews last week, I was cut in the middle of the interview and it was ended once they discovered I'm not a senior engineer. One of them, supposedly saw my resume before hand and I did great in their online exam.

I have some projects yes, but not big enough for them.

In only one job, the requirement was an exceptional algorithmist. I'm not exceptional, but I applied anyways.

They sent me three problems. I solved two and sent them some thoughts about the third one, which was very difficult. I found several papers related. It was a publication level algorithm. Even my algorithms professor spend a day on it before giving up. I think I have some thoughts about a solution, but I needs more time than I can afford at this stage. Still waiting for their reply though.

<comment><USER2> Do you mind linking your resume (Anonymize it beforehand if you wish)? 1 interview for 10 applications is low but not unheard of, but if you get cut for those because they somehow never noticed you're not senior, your resume itself may be misleading. The alternative is they're lying and you're failing interviews for a different reason, probably behavioral or something strange about your background, and nobody is telling you. If you can link to an example job you have applied or would apply for that would help too.

I'm a mid-level C++ engineer -- if anything I can tell you where your current experience is compared to our requirements for junior jobs, if your resume is fine information-wise and what kind of thing may be tripping up interviewers. I've interviewed juniors and I've never told them they needed a ton of experience -- and most of our juniors have science or engineering PhDs but zero industry experience.

<comment><AUTHOR> Sorry for the late reply. I might do that soon. Since you have experience interviewing, I want to know if this is normal. I was invited for A one-way video interview (a quick Q&A you'll answer using your webcam).

Is this normal? I find it humiliating to be honest.

</comment></comment></comment></comment></comment></comment><comment><AUTHOR> Should I interpret not getting response about my question for a project idea as a sign that it is not a good idea?

<comment><USER3> I think the other commenters suggesting a better role is the best idea. Believe it or not ... there is a lot of industrial R&D ... people don't publish papers on all of it. Key outputs are Proof of concepts and patents. If you find a role like that, you will likely have the best chance to succeed.

That said, lets talk about the project idea .. here is what I suggest. Do a solid project (or three) and give a talk on it at a meet up or tech conference.

Data science/ML is stupid hot right now as an area. But the business people don't give a crap about algorithms. They want outcomes or whatnot. So, when you do a project, don't go fully deep into an algorithm or eval. Focus on a business problem (could be some trivial data analysis on open data) and write a blog post on it/do a talk. Use visualizations. use tools used in industry for this (e.g. Tableau or whatever).

Best of luck to you.

<comment><AUTHOR> I agree. But all data mining/machine learning projects I can think of are either trivial or typical.

That is why I was asking for suggestions.

Thank you.

<comment><USER2> The Kaggle competitions are good projects, just don't expect to win. I like it because I don't like studying on toy stuff. I hear it can be a social thing for some too so maybe you will meet people in your area that know of jobs for PhDs.

<comment><AUTHOR> Good idea, I will check it out.

</comment></comment></comment></comment></comment><comment><USER4> What's your PhD in CS subarea?(dissertation) Are there any jobs in that area? Why not teach?

<comment><AUTHOR> My PhD is in Computer Science (mix of algorithms and data mining and some bioinformatics). I switched advisers few times. I can teach, I love teaching and I have huge experience being a teaching assistant. But there are some issues with teaching right now: 1-Most universities require teaching and research. 2-I want to move to software engineering work. 3-If want more and not start software engineering now, as a fresh PhD graduate, the problem will be worse later.

<comment><USER3> I think you are over glorifying software dev. Most devs don't do google/MSFT/Netflix-style SE. Most do the same crap we do in grad school except they have 100% more meetings and progress reports to fill out.

When you say Bioinformatics, I assume your main skills are in Python? That is going to be a problem as a software dev unless you stick to data science/ML. Professional work requires expertise in Java (boring but necessary) and C++ (hard but efficient). Make sure you understand concurrency/parallelism/locking in your tools/languages.

<comment><AUTHOR> I know python and c++03. I agree that "concurrency/parallelism/locking" could be useful to me. May automotive companies ask for that and they also ask for some algorithms knowledge.

Do you have any project idea in that area? Thank you for your help.</comment></comment></comment></comment>