
Ask HN: What finished/done/complete software do you use? - codesections
What software do you personally use that is finished and no longer being developed or updated?<p>Note that I&#x27;m asking about the status of the software, not about your personal use – for example, vim is still under active development and thus does not count as &quot;finished&quot; software, even if you continue to use version 7.
======
huhtenberg
WinAmp 2.95

uTorrent 2.2.1

These should've been the final versions of either software, because despite
their age - 20 and 10 years old respectively - the functionality and the UX
are still nearly perfect and none of later versions carried any meaningful
improvements.

~~~
speps
qBittorent is a very good replacement for uTorrent:
[https://www.qbittorrent.org/](https://www.qbittorrent.org/) no need to stay
on an old uTorrent that won't support BitTorrent v2 for example.

~~~
huhtenberg
I completely disagree.

qBittorrent may be a decent software, but the older uTorrent is a true
masterpiece of engineering and design. Incredible fit and finish with _zero_
operational problems. So why would I want to throw away a Porsche and switch
to some Civic?

Once BTv2 arrives and gets more or less decent adoption, then, yeah, we may
need to find a replacement. Until then switching will not solve any
problems... because there aren't any.

~~~
iso1631
does uTorrent support bittorrent v2?

------
llimos
Windows notepad. Permanently pinned to my taskbar. Opens instantly, nothing
better for jotting something down quickly

~~~
codesections
Is Windows Notepad really "finished", though? I'm not a Windows user, but my
impression was that it's still being updated with new versions of Windows. A
quick search turned up a post[0] listing many new features added as recently
as 2018, which indicates it was in active development pretty recently at the
very least.

[0]: [https://www.howtogeek.com/359042/everything-new-in-
notepad-i...](https://www.howtogeek.com/359042/everything-new-in-notepad-in-
windows-10-redstone-5/)

~~~
llimos
According to Wikipedia[1] there was one update in Windows XP 17 years ago,
then that one two years ago... that seems pretty much like 'done' to me

[1]
[https://en.wikipedia.org/wiki/Microsoft_Notepad](https://en.wikipedia.org/wiki/Microsoft_Notepad)

~~~
codesections
> According to Wikipedia[1] there was one update in Windows XP 17 years ago,
> then that one two years ago... that seems pretty much like 'done' to me

That's not really how I read the linked Wikipedia article. It says:

> Notepad was added to the Microsoft Store in August 2019… [and will be]
> receiving updates through the Microsoft Store. This will allow updates to
> the app to be delivered more frequently.

I read that as indicating that development is ongoing.

~~~
llimos
> I read that as indicating that development is ongoing.

Shame. I hope they don't ruin it...

~~~
joelvalleroy
Notepad is discontinued, please use NotepadVR instead.

~~~
llimos
It was bad enough when they replaced Solitaire and Minesweeper with more
'fancy' versions

~~~
smegcicle
and freecell with one you couldn't play with the numpad

------
gscho
Moment.js [https://momentjs.com/docs/#/-project-
status/](https://momentjs.com/docs/#/-project-status/)

~~~
ethbr0
To close the loop:
[https://news.ycombinator.com/item?id=24477941](https://news.ycombinator.com/item?id=24477941)

~~~
codesections
Yep, the discussion in that comment thread was what prompted me to post this
Ask HN. Fully finished software _does_ seem to be rarer than it should be.

------
ghoward
I use bc. There's only so much you can add to it.

I also think programmers should try to finish the software they write.
[https://gavinhoward.com/2019/11/finishing-
software/](https://gavinhoward.com/2019/11/finishing-software/)

~~~
skocznymroczny
I assume bc doesn't stand for Borland C?

~~~
ghoward
No. :) It is a POSIX utility.
[https://en.m.wikipedia.org/wiki/Bc_(programming_language)](https://en.m.wikipedia.org/wiki/Bc_\(programming_language\))

------
niilohlin
I would say that (La)TeX is probably the closest thing to "finished" software
that I use on somewhat regular basis.

> A work is never completed, but merely abandoned.

~~~
codesections
LaTeX appears to be under active development. Its most recent release was just
over two weeks ago: [https://www.latex-project.org/news/](https://www.latex-
project.org/news/)

~~~
JadeNB
Yeah, better to say that TeX is (nearly) finished, with LaTeX still a roiling
mass atop it.

------
quickthrower2
YNAB4 budgeting software

Hope this counts, this is the end of life for the desktop product but they
rewrote it as a web app but that is substantially different.

------
stevesearer
I still use Picasa (from Google) every day to organize and export photos.

It hasn’t received updates in years and doesn’t work on the latest versions of
MacOS, but I still haven’t found anything else to replace it. While there are
other photo organizers and other photo editors, this hit the sweet spot for me
in addition to being fast.

~~~
karmanyaahm
Maybe something like digiKam would be an alternative?

~~~
stevesearer
I'll check that one out, thanks for the rec.

I am in the process of testing out Movavi Photo Manager which seems to check a
lot of the boxes I'm looking for: [https://www.movavi.com/photo-organizer-
mac/](https://www.movavi.com/photo-organizer-mac/)

------
hooby
I'm not quite sure I agree with the premise that a software is not to be
considered "finished", until the moment it is abandoned.

There's a lot of software that I wouldn't want to use, if it doesn't at least
still receive regular security updates.

I'll dare to go out on a leg here, and claim that a software that has a
complete and stable set of core features probably can be considered "finished"
\- even if it still is under active development and receiving new features.

~~~
ghoward
I disagree. I think that software is only finished when new features are not
being added. I believe it is possible to watch for bug reports and fix them,
which means the software is still maintained, but in order to be finished, I
think users can expect that the only updates will be for bug fixes.

That said, I am not sure it's possible for a library to ever be "finished" in
that sense; maybe only programs can be.

~~~
hooby
Well the question here is, what criterion is more important for being
finished:

A.) having a complete and stable set of core features

B.) no more new features being added

To me personally, A.) is way more important and way more indicative of
"finishedness" than B.) is. Surely both criteria do play into this - but imho
there's more weight on A.) than there is on B.).

Let's look at your example: VIM. According to criterion A.) it is finished -
because it has a complete and stable set of core features, which haven't
changed much in many versions (and many years).

According to criterion B) VIM is absolutely not finished, because it still is
under active development and new features are still being added.

Let's look a different example - I suggest looking at a piece of imaginary
vaporware. Maybe a few design documents exist - but not a single line of code
has ever been written. The project has been canned before it even started. No
new feature is going to get added to this software ever.

According to criterion B) this software does count as finished - because no
new features are being added.

According to criterion A) this software is not finished at all, because it
doesn't have a single core feature, let alone a complete set of core features.

Now those two examples are sitting at the very extremes... things do get more
interesting if we compare two examples that are a bit closer to the middle:

Which one is more finished?

1.) A piece of software that just hit version 1.0 - it has all it's core
features completed, is fully usable, but is still under very heavy
development, and might release 2.0 sooner rather than later.

2.) A piece of software sits at version 0.8 and all development has ceased.
It's mostly complete, but still missing a few core features - but it's no
longer getting any updates at all.

I personally tend to see 1.) as the more finished piece of software of those
two. And that means that to me, having a complete set of core features is more
important than no longer having new features added. I simply can't see 2.) as
finished, since it's incomplete even at it's core.

I believe the Vaporware example shows, that you totally have to weigh in
"complete set of core features" as well. Imho at more weight than "no new
features" has.

And when weighing things that way, a piece of software with a stable set of
core features can be pretty finished, even if new features are still being
added. Simply because that complete-set-of-core-features part is so much more
important than the no-new-features part.

~~~
codesections
I don't entirely disagree with your perspective, but evaluating what counts as
"a complete and stable set of core features" gets very tricky. For example,
you said

> Let's look at your example: VIM. According to criterion A.) it is finished -
> because it has a complete and stable set of core features, which haven't
> changed much in many versions (and many years).

From my point of view, that's not an accurate description of Vim. Vim 8
(released in late 2016) added several new features. Most notably:

> Vim can now exchange messages with other processes in the background. This
> makes it possible to have servers do work and send back the results to Vim.
> See |channel-demo| for an example, this shows communicating with a Python
> server.

(Source:
[https://raw.githubusercontent.com/vim/vim/master/runtime/doc...](https://raw.githubusercontent.com/vim/vim/master/runtime/doc/version8.txt)
)

I personally view this as a major new core feature – one that enabled a whole
new class of plugins, including many Language Server Protocol plugins. For the
ways I use Vim, that's a core feature. Maybe it's not a core feature for you,
but that's exactly my point: what is and isn't a core feature depends entirely
on an individual's usecase.

> Let's look a different example - I suggest looking at a piece of imaginary
> vaporware. Maybe a few design documents exist - but not a single line of
> code has ever been written.… According to criterion B) this software does
> count as finished - because no new features are being added.

I agree that criterion B) would characterize this as "finished", but I
disagree that it would count as "finished _software_". Maybe it's a finished
design document, but if no software was produced, then it's not finished
software.

Incidentally, it's obviously possible for software to be both 100% finished
and not very useful. For example, the K&R C "Hello, world" program is finished
– it doesn't need any updates and perfectly fulfills its specification. But
that doesn't mean I'm planning to use it daily!

~~~
hooby
I fully agree - that can be very tricky indeed.

But I think your response on VIM does add another great point to this
discussion: nobody would have considered VIM incomplete for not having JSON
support, before JSON even existed. In theory, VIM could have been complete AND
finished earlier without JSON-support, back in the day before JSON.

But then JSON happened - and suddenly VIM suddenly no longer had a complete
set of core features. And not being complete means not being finished - since
being complete is pre-requisite for being finished. And doesn't that mean,
that a piece of software which does NOT get new features, can't stay
"finished" when things change and new requirements emerge? Doesn't a piece of
software have to get new features so it can stay (close to) finished - and
doesn't revert back to being incomplete?

The only way a piece of software could ever stay "finished" without getting
new features is, if it was used for something that no longer sees any change
happen or any new requirements emerge - it basically has to be a completely
non-evolving field of work with static, unchanging requirements. But any
active, evolving field of work will always see changes and new stuff and
subsequently new requirements will emerge. Software has to react to those
changes in requirements.

~~~
codesections
> And not being complete means not being finished - since being complete is
> pre-requisite for being finished. And doesn't that mean, that a piece of
> software which does NOT get new features, can't stay "finished" when things
> change and new requirements emerge? Doesn't a piece of software have to get
> new features so it can stay (close to) finished - and doesn't revert back to
> being incomplete?

That's a really interesting question. I guess some of it comes down to whose
perspective we're looking at the software from. I'd tend to look at it from
the author/mountaineer's point of view: If Bram Moolenaar had declared that
Vim was complete with version 7 and would never add major features like
async/JSON support, I'd probably say that the program was "finished", even if
it lacked certain features that I'd like it to have. (Those missing features
might cause me to use a different piece of software, but I don't think they'd
give me cause to complain that the hypothetical Vim was "incomplete")

(And, indeed, there was a period ~5 years ago where it looked like Moolenaar
might go that route, especially with respect to async support. My
understanding is that his initial unwillingness to add async support/other new
features was a big part of the impetus for Neovim.)

> The only way a piece of software could ever stay "finished" without getting
> new features is, if it was used for something that no longer sees any change
> happen or any new requirements emerge - it basically has to be a completely
> non-evolving field of work with static, unchanging requirements.

I'm not sure that the entire _field_ needs to be static. For example, Quake
strikes me as a finished piece of software – that doesn't mean that video
games (or even first person shooters) aren't evolving. It just means that
Quake carved out a narrow section of that field and finished delivering on its
design goals within that narrow slice.

------
phab
TeX and MetaFont [0].

Although to be fair, I also use LuaTeX quite a lot now...

[0] [http://www.texfaq.org/FAQ-TeXfuture](http://www.texfaq.org/FAQ-TeXfuture)

------
btschaegg
If you're looking at manpages on some UNIX derivates (non-GNU), `troff` might
be involved. AFAIK, that would very much qualify, even though the main reason
might be that no one was able to decipher its code…

It looks like you can find a mirror of the Plan9 source for troff here:
[https://github.com/hollingberry/troff](https://github.com/hollingberry/troff)

------
jraedisch
Spectacle for Window Management on macOS
[https://www.spectacleapp.com/](https://www.spectacleapp.com/)

Works perfectly and has not changed for a while.

It seems to be superseeded by
[https://rectangleapp.com/](https://rectangleapp.com/)

------
arantius
ClipX ( [https://bluemars.org/clipx/](https://bluemars.org/clipx/) ) Mezer
Tools ( [https://bayden.com/mezer/](https://bayden.com/mezer/) ) AllSnap (
[https://github.com/iheckman/allsnap](https://github.com/iheckman/allsnap) )

No updates in years (this thread is making me realize one does have, minor,
updates actually ...). Do what they do perfectly. (Except, only on my laptop,
ClipX will randomly crash/close.)

------
Normille
NValt [0] for all my note-taking needs

DateTree [1] for organising my photos into folders by date

TextMate [2] for my default GUI text editor. I s'pose it's not really
officially 'finished' but, given that entire civilisations rise and fall
between major releases, I'm counting it as so.

[0]
[https://brettterpstra.com/projects/nvalt/](https://brettterpstra.com/projects/nvalt/)

[1] [https://www.orange-carb.org/DateTree/](https://www.orange-
carb.org/DateTree/)

[2] [https://macromates.com/](https://macromates.com/)

------
elvis70
I was going to say xsnow but I realized that it was still maintained:
[https://sourceforge.net/projects/xsnow/](https://sourceforge.net/projects/xsnow/)

------
JadeNB
Skim PDF reader [https://skim-app.sourceforge.io](https://skim-
app.sourceforge.io) . Some macOS update made Preview refuse to search within
old PDFs. Skim still will.

------
asicsp
Not sure if it is still being developed/updated, but I use tkdiff as my gui
diff viewer. I have an alias for it when using with git

    
    
        git difftool -t tkdiff -y
    

My software folder shows I had downloaded .gz copy in 2014 (that'd be the year
I switched to Linux permanently). I use it because that's what I had used in
my job and 99% of the time I just need to view the difference and use n/p keys
to move around, nothing else. I only wish there was a way to wrap the long
lines instead of having to use horizontal scroll bars.

~~~
codesections
Looks like tkdiff is still being developed and had its most recent release in
June:
[https://sourceforge.net/p/tkdiff/news/](https://sourceforge.net/p/tkdiff/news/)

~~~
asicsp
Thanks. I checked it out and I think I'll stay away from sourceforge in
future. Annoying pop-ups, redirections, waiting time for download and not even
doing that properly the first time.

------
emaildanwilson
Wii Homebrew:
[https://wiibrew.org/wiki/Homebrew_Channel](https://wiibrew.org/wiki/Homebrew_Channel)

------
meehow
This is interesting one:
[https://github.com/snark/jumpcut/commits/master?after=7f9772...](https://github.com/snark/jumpcut/commits/master?after=7f97720bf84486c6f66e2b2e6a61a1b77fee5ddd+69&branch=master)

It was unmaintained for 7 years (at the time when I was using it), but looks
like it's alive again. It's a simple program which "just worked".

------
thisispete
There are so many apps that I wish the developers would stop ‘adding features’
to and simply maintain with changing os’s and security whatnot. But sales
people want forever new features to justify charging for a new version in an
arms race against competitor software. Abandoning the idea that software
should be a tool and promoting software is a service is incredibly
problematic.

------
n0n0n4t0r
Winmerge 2 It stayed without new release several years, and was still the best
I could find on windows

------
knowhy
ratpoison
([https://www.nongnu.org/ratpoison/](https://www.nongnu.org/ratpoison/))

a simple tiling Window Manager modelled after GNU Screen. It hasn't seen any
updates in 3 years but still works very well for me.

------
meehow
[https://github.com/boltdb/bolt](https://github.com/boltdb/bolt)

[https://github.com/jung-kurt/gofpdf](https://github.com/jung-kurt/gofpdf)

------
apogosyan
Xee3 image viewer on Mac
([https://theunarchiver.com/xee](https://theunarchiver.com/xee)). Hasn't
updated in 3 years.

------
tlackemann
jrnl.sh [0] - Local notebook/journal software. Nothing fancy. Works.

[0] [https://jrnl.sh/](https://jrnl.sh/)

------
jerome-jh
csearch/cindex has not changed for 5 years, pretty useful and reliable
[https://github.com/google/codesearch](https://github.com/google/codesearch)

cscope: last version in 2012, combined with Vim
[http://cscope.sourceforge.net/](http://cscope.sourceforge.net/)

[edit] actually codesearch received 2 fixes in 2018

------
cobbaut
I have an offline computer with Windows 7. The computer does not have a
network card and I use it to play old (obviously offline) games.

------
ed_at_work
Microsoft Money. It's the "sunset edition". No updates anymore. Nothing comes
close to it's cash flow forecast.

~~~
smichael
Cool. What's good about its forecast ?

------
bondant
nload - displays the current network usage

Hasn't been updated since 2012, but I use it everyday. [http://www.roland-
riegel.de/nload/changelog](http://www.roland-riegel.de/nload/changelog)

------
hprotagonist
tex/latex.

i3wm is really damn stable.

i haven’t updated emacs in 3 years but i hear 27’s cool.

i also haven’t updated irssi in forever.

------
s369610
jujuedit [0] - utf8/hex/file-on-disk editor fast and small and native

[0] [https://jujusoft.com/jujuedit/](https://jujusoft.com/jujuedit/)

------
mantas
Bill free. Invoice generating app for Mac OS. It just works.

------
n0n0n4t0r
Windows XP each time I use a DAB? (troll inside)

------
3ds
TeX is done.

------
pks016
MPC-HC

------
mtrycz2
grep, pretty often.

All of the busybox alises, actually.

------
qntty
python 2

~~~
jerome-jh
It is a bit more than finished, it is stale. I mean you should not develop new
things on an outdated language/runtime.

