
Ask HN: What niche/forgotten technologies do you wish were more mainstream? - atombender
...Or you wish that we&#x27;d bring back or learn from more?<p>There&#x27;s a lot out there. Occasionally I bump into systems, languages, techniques, etc. that I haven&#x27;t heard of, and which don&#x27;t seem to be popular, for whatever reason. For example, how many people use Clean, the pure functional language?<p>History is also littered with largely abandoned things like Prolog (which mostly survives in Erlang), Datalog, hierarchical databases, object databases, etc., some of which were experimental, others which were failed attempts at creating a shiny new thing. I suspect that while much of the abandoned tech would be hard&#x2F;pointless to revive, there are ideas to learn from them.<p>Then there are technologies that are keeping people and companies productive and successful, but since there&#x27;s no hype surrounding them, and productive people prefer staying productive, the grapevine is basically silent. For example, I was surprised to learn that Apache Storm, which has seemingly dropped off the big data radar, is still an active, popular project. Another project, ActorDB, keeps coming up on HN, but you never heard about anyone using it.<p>What&#x27;s your favourite neglected technology?
======
vram22
I don't know if it is forgotten/neglected or not, but the product called Magic
(with some variations for marketing/tech) from Magic Software Enterprises was
somewhat interesting to me. It was a product that let you build CRUD (with
maybe some more features) apps rapidly, using something like a GUI tool with
just 14 CRUD-related menu actions or so. It may have had a runtime that you
could then use to run apps created using that tool, probably in some
proprietary format of theirs. I never actually used it. But I heard about it
from ex-colleagues in a company where I had worked earlier. They were a small
software house developing custom business apps for clients. Soon after I left
there, I heard from a friend who still worked there, that they had started
using it for building apps for clients, due to the productivity benefits. I
think it was originally an Israeli company. They also started a subsidiary in
India later, I read.

Just checked again, some links:

[https://en.wikipedia.org/wiki/Magic_Software_Enterprises](https://en.wikipedia.org/wiki/Magic_Software_Enterprises)
(Caveat: Just saw a Wikipedia notice at the top of that page.)

[https://www.magicsoftware.com/](https://www.magicsoftware.com/)

If anyone has used it, interested to hear your experience with it.

------
atombender
For me, I mentioned object databases a bit, and I think there's still a gap
here not yet filled by RDBMSes or NoSQL.

The old object databases (now mostly-forgotten products like POET,
ObjectStore, Matisse and Objectivity) were too tightly tied to a serialization
format. Many of them wanted location transparency, where your app just worked
with "objects", and they happened to be remote and persisted to disk — the
same awful design mistake that doomed CORBA and, to an extent, DCOM. Turns out
this data model requires a tight coupling between a language's OO classes and
the persistence model, and it's also means that code that looks like it's
working on RAM objects can't optimize for data paths in the way that SQL can.

Then there were systems like GemStone and Caché, which were tightly coupled to
a single language/runtime (Smalltalk and M respectively). Probably very
productive, but ultimately a dead evolutionary end.

At this point I think it's possible to have a hybrid database that's good at
both relational-type and object-graph-type queries, i.e. to collect a huge
amount of structured data with joins etc., but without the tabular
requirement.

~~~
scarface74
What’s the difference between an object database and a database like Mongo? I
used Mongo with C# and Linq and used strongly typed Linq queries that looked
and worked exactly the same whether you were working with an in memory List<T>
or a IMongoQueryable<T>. Of course when you work with an IMongoQueryable the
Linq is translated to MongoQuery at runtime.

~~~
atombender
I don't know Mongo or C#/LINQ very well, but I'll take a stab. For the most
part, you could probably replicate the classic object database experience with
MongoDB, assuming a sufficiently rich language integration.

For example, in most of these databases (e.g. POET), you'd do something like
"p = db.persons.find(1)" and then call p.save() on it to make your changes
persistent. You could also wrap multiple save calls inside something like
Tx.begin() and Tx.commit(), and everything in between would operate within the
transaction (which of course leads to an interesting challenge where objects
"belong" to a specific transaction, and a rollback has to invalidate them).
You could build something like this on top of Mongo, I think.

You could also do "p.employers[0].board.chairman". The access would be
seamless and transparent. Under the hood, it would use the object graph to
find and load the right object from the server. In other words, dereferencing
a pointer to another object would follow the graph. This requires some
language magic. With many of these products, you would write normal OO classes
(often C++ and Java back then; Matisse supported Python), and then there were
tools to inject the magic persistent code needed to get this level of
transparency. The Java version of POET took your compiled .class files and
modified the bytecode so that "p.employers" or whatever actually called the
database to load itself. You'd have to have a step in your build pipeline to
call this tool. I bet LINQ would make this easy.

As an aside, for many years none of these databases supported any type of SQL-
type query; you were expected to use the graph. You'd always start with a root
to "reach" any part of the graph. So you'd do "db.persons" or "db.companies"
or whatever; what the root contained would be up to you, usually. But any
filtering would have to be done client-side; so if you're looking at a subset
of companies, you'd have to something like db.companies.filter(lambda c:
c.stockPrice > 10). It could be quite fast since clients could cache all the
objects it fetched, and listen to changes from the server to invalidate them.
On the other hands, no joins. Later, there was an attempt at standardizing a
query language called OQL (which would allow db.query("from company where
stockPrice > 10") or whatever), but it was too little too late.

It's worth pointing out that many of these object databases prided themselves
in being able to keep the in-RAM copies in sync. So if you hold on to that "p"
variable, and someone makes a change to the Person object with ID 1, then
changes are reflected in _your_ copy, automatically. So the client would
listen on a server channel to receive change notifications (similar to MongoDB
change streams, I guess). Every time you fetched an object, you'd basically
start a subscription to changes on that object.

One thing that these object databases had that Mongo doesn't (as far as I
know) is strong references. If your person object has a reference to a company
object, then you can't delete the company without first unsetting it from the
person. This is a good thing.

~~~
scarface74
C#'s Linq lets you treat queries as first class citizens.

For instance:

say you have:

var customers = db.GetCollection<Customer>().AsQueryable();

Where Customer is a C# object and it can have nested objects.

When you right a query:

var seniors = from c in customers where c.Age > 30 select c;

Assuming that db is a Mongo context object and hover over the seniors variable
at runtime, you will see the MongoQuery that is generated.

If you then write:

seniors = seniors.where(s => s.age < 90)

It will add the second predicate and modify the MongoQuery at runtime.

The query isn't actually run until you do something like

var oldCustomers = seniors.ToList();

If you went in and changed the customers initialization to an in memory
List<Customers>, the same queries would still work, the ToList() it would
generate actual code instead of a MongoQuery.

If customers were a reference to an Entity Framework SQL Server DbContext, the
same Linq statements would generate SQL.

You can even write a method that takes in a Linq expression:

List<Customers> Find(Expression<Func<bool,Customer>>)

and call it

var oldFolks = Find(c => c.Age > 65)

C# translates Linq expressions to Expression Trees and then the Linq provider
you choose (or write) parses the expression tree at runtime and converts it to
the appropriate query language or for in memory lists, code.

You could switch out Mongo for an RDMS and all of the clients using the Find
method would be non the wiser.

I guess OQL is a lot like Linq but since C# understand Linq natively you get
strong typing, support for joins, etc.

~~~
atombender
Right, this is a bit different and not really seamless (e.g. an object
database wouldn't require a ToList()). The ability to express queries this way
is nice, though.

~~~
scarface74
The idea of ToList(), .Count() etc., is that the query isn’t executed until
you use such a function, you can keep composing the query and it will be
translated and run on the server instead of the client.

For instance....

var seniors = customers.Where(c => c.Age > 65).ToList()

foreach(c in seniors) {}

Will be translated to a query and run on the database server.

var seniors = customers.ToList().Where(c => c.age > 65)

foreach(c in customers) {}

Will give you back the same results, but you will get back _every_ record in
the table/collection and the filtering will be done client side.

Btw:

The first query could be rewritten as

var seniors = (from c in Customers where c.Age > 65).ToList().

You would only do .ToList() if you want to keep the scope of the connection
small if for instance you are passing it outside of the class.

You can iterate the results directly from the query instead of returning the
results in memory (using ToList()) and it would work just like any other
database style cursor.

EDIT:

Just to clarify from my first post, the example should have been

List<Customers> Find(Expression<Func<bool,Customer>> predicate)

{ .... return customers.Where(predicate).ToList();

}

This pattern also works great for unit testing. You can mock out your database
Context and use a List<T> Customer to store data and you can still test your
queries without having a dependency on a database.

------
beagle3
nntp / usenet. It had moderation problems, because it was built for the world
where the internet was academics only, but it worked great before everyone
came to the internet, and it still works great if posting permissions are
properly managed (say, a company internal nntp server).

The problems with nntp where of the same kind that email has with spam these
days, except they arrived there earlier.

However, the thing that really killed nntp was the fact that it was not
supported in Outlook, at a time when Outlook was dominant enough to kill it
(and promoting Sharepoint groups at the same time, which were inferior at the
time).

So we are now left with google groups (proprietary, and hosted, and only by
google), mailing lists (which are inferior in most ways, especially
onboarding), phpBB and similar forums (which are inferior in most ways, except
moderation).

~~~
stevekemp
In these days of "distributed stuff" I'm surprised there isn't a popular forum
which uses NNTP for topic/thread storage, and is basically a presentation
layer on top of that back-end.

~~~
beagle3
[http://gmane.org/about/](http://gmane.org/about/) is more or less what you're
referring to, and there are others. But the thing with nntp is not the storage
- it's the fact that it is standardized.

It is extremely convenient to write a newsgroup post, and cc: someone in
particular, and when they do a "reply all" the newsgroup is a recipient as
well. This does not work with any "forum", and works (but not well) for
mailing lists.

------
LarryMade2
\- Most recently is the 3D/Tilt web page view feature that was deprecated on
Firefox, it seemed kinda useless but was a great tool to visually
analyze/debug a pages' structure. ( [https://www.wrock.org/3d-visualization-
in-firefox-tilt-inspe...](https://www.wrock.org/3d-visualization-in-firefox-
tilt-inspector-view/) )

\- Some better general purpose database.

One of the best ones was ApplWorks/ClarisWorks database. Pretty
straightforward to make a nice flat file database, pretty report creator, etc.

MS Access is overkill and OpenOffice/LibreOffice, last I used it, was kinda
unusable.

\- PrintShop/PrintMaster, etc. - Why there is no FOSS version now is beyond
me.

\- Another is the Kooka scanner utility form KDE 3, it had built-in OCR and
was great to work with.

------
beagle3
small checkboxes (or other mark) next to items in selection lists, which don't
go away when you click in the wrong place or accidentally try to add another
one while not holding down ctrl.

Seriously - when you have a large list of which you want to mark substantially
some (say, 20%) of the items, some next to each other, and some not, the
prevailing method of ctrl+shift+click suck horribly (and touch methods only
slightly less).

Back before mice were common, you would have a "mark/unmark this item and move
to the next one" button (typically insert and/or space), a "unmark all"
(typically insert), and it was simple and effective. It's still available in
7zip on Windows, but AFAIK that's basically the last bastion.

------
vram22
ObjectSpace Voyager. It was a Java product for mobile code/agents, etc. From
the company called ObjectSpace.com . Pretty interesting product. I had
downloaded a free edition of it and played around it for a while. IIRC, it did
what it claimed to do. For some reason, it did not seem to take off. IIRC,
ObjectSpace was also the company that developed JGL (the Java Generic
Library), before Java itself got generics, and also, one of the people
involved in it was Graham Glass, who later joined WebMethods, and had
developed ElectricXML earlier (I think).

------
hluska
I am old enough that it's actually hard to answer this question. Mostly
because I can't remember what was actually good and what is just nostalgia.

But, I'm going to say Gopher. Again, this might just be nostalgia, but Gopher
was just so damned usable. I feel like I could learn faster and find higher
quality information via Gopher than the web.

Again though, this might just be nostalgia. It is very hard for me to
critically evaluate the technologies that utterly blew my teenaged mind.

------
beagle3
irc. It's still used by geeks, but all the modern alternatives like Slack and
friends lock the data away from the users, are costly in both money and
resources (Electron apps instead of irc chat apps that can run on a C-64).

Like nntp/usenet in my other post, one of the big problems is security,
control and management especially with respect to bad actors. Perhaps there's
a common way to solve this theme without ceding control of the data, but I'm
not aware of it (and ... based on modern email spam, there is no simple
effective way).

------
Rjevski
SIP (session initiation protocol).

It’s superior to the PSTN in every way, and problems like spam can be solved
just like we did with emails (not to mention, there’s plenty of spam on the
PSTN too).

------
slipwalker
Google Wave ( later renamed into Apache Wave, and now retired ). Maybe i
should just fork the thing and hack around the "next big email killer"(tm)...

------
anoncoward111
Torrenting. Text only browsers and sites like Dillo with information sent over
long distance 3g. Tape storage for dense files and media.

------
marktangotango
Mainframe style time sharing in a web server, cloud without vms and
containers.

------
icedchai
Usenet / NNTP.

------
rs86
Object databases are hardly forgotten

