Slashdot Mirror

It's GPL-ed, works with both Java and .NET (Vista has it built in).
Can easily make simple GUIs or use pre-made ones.
http://www.db4o.com/

Android is fully based on Java.

Being a developer of an open source java database myself, I am absolutely thrilled.

This is the the single best possibe thing that could have happened for the success of Java on devices. This SDK will be decisive for how software will be written for the masses in the future: With Java. Don't forget: The number of mobile phone users without a PC will soon be an order of magnitude higher than the number of PC users.

Whenever I see a comment that pair programming does not work I feel sad for the person that wrote it. Maybe you were very unlucky with the peer you were working with, maybe you were unlucky with the task that you were working on.

Without pairing my work would only be half as much fun and I would really miss the opportunity to learn from other people.

Some thoughts taken from a recent blog post that I wrote:

- Pairing keeps you completely focussed on a single important task. This benefit alone at least doubles the productivity of every developer and makes pairing cheaper.
- Pairing produces better designs that last longer.
- Pairing prevents simple mistakes and saves you from loosing time in the debugger.
- Pairing fosters shared knowledge about the project that is being worked on. It makes it easier to exchange people between tasks.
- Pairing helps learning. People teach eachother programming techniques, patterns and ways of working with IDEs.
- Pairing helps raising the spirit of the team. It has worked extremely well to glue our team together, although we only see eachother in real life twice a year.
- Pairing activates the speech area of your brain and makes you more creative.
- Pairing is fun.

Also take a look at db4o, which gives you dead-simple object persistence without the rdbms underneath. Makes perfect sense when you're not actually using relational data, just storing objects (like 99% of rails-type apps do). As a bonus, it can replicate to Hibernate, which is perfect for reporting and data mining (personally I'd just cut the middleman and use Hibernate on both ends, but their replication is designed more for lots of small cache clients pushing changes into a bigger db).

Interesting! The new BDB Java release does attempt to store objects directly. That's quite an advance in comparison to the awkward API of BDB 2.x.

However BerkeleyDB JE is still years behind db4o. The querying functionality of BDB is very rudimentary. It requires manual selection of indexes to be used, not really sophisiticated in comparison to db4o's Query-By-Example and Native Query concepts.

It would be interesting to see BerkeleyDB and db4o race head to head in the Poleposition benchmark.

While it may be true that the SQL database market has become a commodity market, SQL databases have never solved object persistence nicely: SQL always remained a foreign language in Java and C#. The object-relational mismatch has forced us to write billions of lines of code over and over again.

Alternate technologies are currently seeing a revival:

- A new portal on object databases was recently launched:
http://www.odbms.org/

- Object databases are going open source:
http://www.db4o.com/

- Microsoft has released LINQ to relieve developers from having to write SQL strings. Code that interfaces with the database is now checked at compile time:
http://msdn.microsoft.com/netframework/future/linq /

- Native Queries show that Java and C# can be directly used to express typesafe queries:
http://www.ddj.com/documents/s=9948/ddj0602e/0602e .html

In case you are using an object-oriented programming language, you may ask yourself if SQL really is a good choice. SQL is not object-oriented, it's use is usually neither typesafe nor compile-time checked in OO languages, it can't be refactored from an object-oriented IDE and it does not follow OO principles.

Food for thought:

Native Queries
http://www.db4o.com/about/productinformation/white papers/

DLINQ
http://msdn.microsoft.com/netframework/future/linq /

Some indicators that SQL does not have a bright future as a database interface for object-oriented programming languages:

LINQ/DLINQ
http://msdn.microsoft.com/netframework/future/linq /

Native Queries
http://www.odbms.org/
http://www.db4o.com/

What does Oracle have to offer in this direction?

Seeing the Gorilla drive the money out of the SQL stack is a strong sign that innovation is over.

Hi,

in case you are working with an OO language (Java or C# ?), you may consider looking into exisiting frameworks that provide object-oriented replication.

That would relieve you from building features like the following yourself:
- Unique Universal Identifiers (UUIDs)
- Cascaded replication with object member traversal
- Conflict resolution at object level providing callbacks

The following open source object database engine provides such functionality and you may even consider it as an alternative to relational databases for caching your data on the clients:
http://www.db4o.com/

The article is basically saying data has to get smart.

That's precisely what object-orientation is all about: bringing data and behavior together.

OODBMSs such as http://www.db4o.com/ will be key players in this future of his.

See you, Klaus.
Db4o - The Open Source Object Database
Prevayler - Persistence is Futile

Some "new" databases exactly meet your requirements. db4o, the open source object database, native Java and .NET is:

- very lean and not complex at all (one line of code stores any object)
- scales extremely well
- is cross platform Java and .NET
- very performant (up to 44x faster than Hibernate+MySQL, for instance)

Chris
http://www.db4o.com/

Many people in this thread have come up with alternatives to VB.NET. Here is a very strong argument for VB.NET and for the .NET platform in general, whether you want to run on Mono or on MS:

Since Java and C# are very similar, just about all the important open source Java libraries are being ported to C#. Once on C#, they are available for all CLR languages - also for VB.NET.

Some examples:
http://www.db4o.com/
http://bbooprevalence.sourceforge.net/
http://nhibernate.sourceforge.net/
http://nant.sourceforge.net/

Strong libraries is what make up the power of a programming language.

The new database benchmark "PolePosition" shows how much performance Hibernate costs:

http://polepos.sourceforge.net/

For overcoming the object-relational mismatch in resource constrained applications, like on mobile platforms, or where performance matters, you might want to look at the open source object database db4o (http://www.db4o.com/ which is up to 44x faster in the benchmark (http://www.db4o.com/about/productinformation/benc hmarks/).

Chris

The new database benchmark "PolePosition" shows how much performance Hibernate costs:

http://polepos.sourceforge.net/

For overcoming the object-relational mismatch in resource constrained applications, like on mobile platforms, or where performance matters, you might want to look at the open source object database db4o (http://www.db4o.com/ which is up to 44x faster in the benchmark (http://www.db4o.com/about/productinformation/benc hmarks/).

Chris

When all the game data fits in RAM, you can do it like Age Of Empires or Starcraft do it: http://www.prevayler.org/wiki.jsp?topic=MajorCompa niesUsingPrevalence When you can't fit all game data in RAM, you better resort to an OODBMS such as http://www.db4o.com/ See you, Klaus.

database.store(object);

The runtime is a JAR that's about 300KB in size, with about a 1 meg memory footprint.

Companies like BMW and Bosch have chosen it to drive their automobiles and robots respectively.

The best way to get a feel for db4objects is to look at how simple the code is you get to write. For example:

To store a Pilot object:

ObjectContainer db=Db4o.openFile(Util.YAPFILENAME);
try {
Pilot pilot1=new Pilot("Michael Schumacher",100);
db.set(pilot1);
}
finally {
db.close();
}

// Put this in a try-finally block like above
ObjectSet result=db.get(Pilot.class);
while (result.hasNext())
System.out.println(result.next ());

// (use query-by-example)
Pilot proto=new Pilot("Michael Schumacher",0);
ObjectSet result=db.get(proto);
if (result.hasNext()) Pilot firstMatch = (Pilot) result.next();

ObjectSet result=db.get(new Pilot("Michael Schumacher",0));
Pilot found=(Pilot)result.next();
found.addPoints(11);
db.set(found);
System.out.println("Added 11 points for "+found);

Oh, and db4objects works with plain old Java objects. You don't have to implement interfaces, inherit from a particular class, or anything like that.

If you're looking for the simplest, light-weight, zero-administration, embeddable database you could imagine, in my experience, db4objects is it.

(I liked it so much that as of 1.5 weeks ago I started working for the company.)

Best regards,

Dave Orme
--
db4objects senior engineer
Eclipse Visual Editor Project leader (http://www.eclipse.org/vep)
XSWT project leader (http://xswt.sourceforge.net/)

What is the purpose of embedding SQL?

Why would I handicap myself like that, when I don't need ad-hoc reporting and when no other system is going to share my data?

Why wouldn't I just use native Java objects?

See you, Klaus.
http://www.db4o.com/ - The Leading Open Source Object Database
http://www.prevayler.org/ - Do You Still Use a Database?

db4objects makes db4o, an object database that went open source about 2 weeks ago.

Fact is that databases are becoming commodity, so the big vendors are going to pretend like they care while hustling their customers for more services etc.

But what are these alternatives you mention that are so much better suited for every possible scenario?

There is, of course, no tool that meets the needs of every possible scenario. Instead, there are tools that meet the needs of common scenarios. Most of what MySQL is being (improperly) used for could be easily replaced with PostgreSQL. Postgres offer similar performance, but takes a minor hit for data integrity. As a bonus, you gain sub-selects, stored procedures, SQL-92 compliance, and other features of a "real" SQL database.

MySQL is quite decent for something like a blog, but why even bother with a complete server in those cases? An embedded database such as Berkeley DB or HSQL (formerly Hypersonic) would provide better performance and would get rid of security issues inherent in running a complete database server.

In still other instances, SQL databases are misused for large object data storage. In many of these instances, an Object Database such as ObjectStore (or your favorite open source choice of the 1000+ options) will provide better performance, without sacrificing much in the way of database management. (Standard database management tools are usually insufficient for dealing with databases containing large amounts of LOBs.)

Basically, the choice in database and database technology should be carefully weighed against the application instead of saying "I know SQL and MySQL is 1337!"

Some other database options include:

DaffodilDB
SAP DB
FireBird DB
Cloudscape (Soon to be open source)
Xindice (XML Database)
ObjectDB
DB4O
Prevayler