“You cofounded Twitter.com with venture-capital money back in 2006, and it still isn’t turning a profit. In November, the company declined Facebook’s offer to buy it for $500 million. Say what? We admire and respect Facebook. We are big fans, actually. They approached us, and we took it seriously. But we feel like we want to continue this path we’re on — sustaining this innovation — and the time is not right.”  Boston Globe interview with Biz Stone, founder of twitter.

I am voting for this as the #1 bonehead move by a tech company for 2008.

When exactly would be the right time to take $500 million for your company?  How many companies out there dream of this phone call from Facebook?

Note the article says the company has never been profitable and probably will not be for some period of time.

Further, most of the development has been funded by VC’s.  I’d like to know which VC’s.  They must have the worst lawyers/negotiating skills in the business.  How could they let this guy turn down that kind of payback?

We had thought about generating a single column key (something like a hash of the composite elements), but that just seemed wrong.  I always thought a database should model reality, not some arbitrary manifestation to get a tool to work.

In this example we have two tables that look like this:

Table A
——-
A_NAME VARCHAR(200)
A_ID INT
attributes ….

Table B
——-
B_NAME VARCHAR(200)
B_ID INT
attributes ….

They both have composite ids.  A helper table is generated that provides the many-to-many mappings for the two:

Table AB
——–
A_NAME VARCHAR(200)
A_ID INT
B_NAME VARCHAR(200)
B_ID INT

Using standard Hibernate reverse engineering we end up with the following mappings:

Table A Mapping
—————
…
<composite-id name=”id” class=”path.to.entity.classes.AId”>
 <key-property name=”aId” type=”integer”>
  <column name=”A_ID” precision=”22″ scale=”0″ />
 </key-property>
 <key-property name=”aName” type=”string”>
  <column name=”A_NAME” length=”12″ />
 </key-property>
</composite-id>
…
<set name=”bs” table=”table_ab” cascade=”all” inverse=”true”>
 <key>
  <column name=”A_NAME” not-null=”true” />
  <column name=”A_ID” not-null=”true” />
 </key>
 <many-to-many class=”path.to.entity.classes.B”>
  <column name=”B_NAME” />
  <column name=”B_ID” />
 </many-to-many>
</set>  
…

Table B Mapping
—————
…
<composite-id name=”id” class=”path.to.entity.classes.BId”>
 <key-property name=”bId” type=”integer”>
  <column name=”B_ID” precision=”22″ scale=”0″ />
 </key-property>
 <key-property name=”bName” type=”string”>
  <column name=”B_NAME” length=”12″ />
 </key-property>
</composite-id>
…
<!– CRITICAL - Only one side can have inverse=true, the other must have inverse=false –>
<set name=”as” table=”table_ab” cascade=”all” inverse=”false”>
 <key>
  <column name=”B_NAME” not-null=”true” />
  <column name=”B_ID” not-null=”true” />
 </key>
 <many-to-many class=”path.to.entity.classes.A”>
  <column name=”A_NAME” />
  <column name=”A_ID” />
 </many-to-many>
</set>  
…

Table AB Mapping
—————-
…
<many-to-one name=”a” class=”path.to.entity.classes.A” update=”false” insert=”false” fetch=”select”>
 <column name=”A_NAME” not-null=”true” />
 <column name=”A_ID” not-null=”true” />
</many-to-one>
<many-to-one name=”b” class=”path.to.entity.classes.B” update=”false” insert=”false” fetch=”select”>
 <column name=”B_NAME” not-null=”true” />
 <column name=”B_ID” not-null=”true” />
</many-to-one>
…

Be sure to note use of the inverse attribute in the A and B mappings: only one side of a many-to-many can be the ‘owner’ of the relationship.  The owner is denoted with inverse=true setting.  The other side of a many-to-many MUST be inverse=false.  It is completely arbitrary which is the owner, but Hibernate will not work unless there is only one.

So, once the mapping is cleared up we produce fairly normal Java code to create a many-to-many relation:

A a = new A();
a.setXYZZY(”various attributes”);
AId aid = new AId();
aid.setPKPart1(”string”);
aid.setPKPart2(4);           
a.setId(aid);

session.save(a)

B b = new B();
b.setXYZZY(”various attributes”);
BId bid = new BId();
bid.setPKPart1(”string”);
bid.setPKPart2(12);           
b.setId(bid);

session.save(b)

a.getBs().add(b);
session.saveOrUpdate(a);

b.getAs().add(a);
session.saveOrUpdate(b)

session.flush();

Just to be sure, note we are setting the composite id fields manually.  In Oracle this can be done by accessing a Sequence.  Other databases have built-in row ids.

For a project here it was switching operating system to Linux from Windows.  Not particularly bad since they are running Java all-around, but there is always some wierd, buried aspect of Java that you are using that really doesn’t work the same way on Linux versus Windows.  There is also a lot of testing that has to be added in to account for the o/s change to make sure all the programmers didn’t add in Windows-like tendencies: file i/o, file naming, network access, threads, etc…

So, of course, once the first blow was digested the follow-on statement came out that we need Active Directory, which is a Windows product, so need another computer just to run that, but we need everything on a small footprint, and it was going to be a blade server, but is looking to be a standard server, …

I wonder if these statements were well-known, decided months ago and we never were in the loop or did someone have an idea in the shower or maybe had an idea in the shower months ago and never told anyone?  Assuming these kind of things are not limited to software, I am guessing the latter: someone was sitting on a decision that is/will wreak havoc with the rest of the world but has very little affect on them.  So, why mention it?

First, we place the stored procedure definitions inside of a new mapping file:

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<sql-query name="getNextSequence" callable="true">
<return-scalar column="NextVal" type="integer"/>
{ call get_next_sequence(?,:tableName) }
</sql-query>
</hibernate-mapping>


Notes:
- the first argument of the stored procedure is actually an OUT parameter from Oracle.
- the actual name of the output ‘column’ must be specified in the return-scalar field

Then the Java code becomes pretty standard:

Session session = TestHibernateSessionFactory.getSession();
Query query = session.getNamedQuery("getNextSequence");
query.setString("tableName", "Table_X");
Object result = query.uniqueResult();
System.out.print(result);


—-

After dealing with this company you then get a whole $30 for your efforts, most of the work sounds like teaching them to speak English.

My only qualm is we have been using ClearCase, another Rational product, for version control.  This has been less than stellar to the extreme issues of Blue Screens of Death during regular use.  Again, the Rational product versus Subversion, which I think the rest of the industry has been using without a hitch for years.

Just out of curiosity I poked at the pricing for Build Forge: $165,000 for the server and additional fees for groups of user licenses!

I was always curious how software tool companies have survived in this era of open source.  I think in most cases there is a good alternative free tool that probably works better (svn vs. clearcase, cruise control vs build forge, …)  Now it is clear:  The larger shops have bought into the commercial products over a period of many years and like anything else, are loathe to change the way they do business even though everyone involved probably agrees it would be a good idea to change.

The team went into a client review cycle knowing this was a big problem.  The client sat through the entire presentation and demonstration without a question.  Always a bad sign.

As the meeting was closing and everyone was gathering up their things one of the developers asked if the login time was a high priority or not.  (Duh!)

The client lead, while still gathering their things and not even looking up, said, “No.  We have a contract.  We will pay you for the software.  But, we are going to use something else anyway.”

Yang said he remains open to selling Yahoo at the right price, adding “people who know me know I don’t have an ego about remaining independent versus not remaining independent.” Ballmer left room open for future partnerships based on the two companies’ search engines, but was definitive on the point that Microsoft does not plan to acquire Yahoo.

With no Microsoft bid in sight and its Google partnership dead on arrival, Yahoo has reached what many analysts conclude is a strategic dead-end.

Why are Yahoo shareholders so in love with this guy?

I know there are lots of openings where he is working so suggested moving to another project.

He took the advice, waited for a milestone, and said something like “We are at a good breaking point.  I don’t think my contributions have been inline with the team.  Maybe it’s time for me to move on?”.  They said thank you for your idea.  Get back to work (not really).

Next day, team management calls him in and says “We would like you to take over architecture for the product.  This will entail much detailed interaction with the team lead.”

WTF?

For another situation a database job that had been running for some time on the first of the month apparently stopped working.  Upon investigation, the job had been completely removed from the system.  This was done when another client’s data was moved onto the database server.

In both cases New things, that are good ideas, were implemented in such a slipshod manner that existing, functional aspects were trashed.

Thinking about this some it seems like this is a very common occurrence: the developer of the New thing has the priority of getting the New thing done.  Old things take a distant second in anyones mind - developer, pm, client - anyone.

I know you can use a regression test suite to verify you didn’t break something, but this is an afterthought.  It is not in the developer’s frame of mind to determine what else might be affected by the New thing.  From my own experience if you happen to think of side effects you get looked at with squinted eye, not a team player, naysayer, problem child.

Further, fixing the broken Old thing after the fact is also looked at as a good thing.  “Yes, we fixed the Old thing.  It turns out the New thing broke it.”  Everyone is happy that the Old thing got fixed.  No one asks why this wasn’t discovered beforehand.

You can see this on software developer web sites.  Everyone can develop something New for you.  Or even more interesting they can debug your code or evaluate your system performance.  No one is advertising they will maintain your current system.  System maintenance is not valued.

Maybe this is just a trickle-down of the quarterly hockey stick affect working into how things get coded.  Imagine that, developers modeling their behavior after sales people.