Who we are

We are the developers of Plastic SCM, a full version control stack (not a Git variant). We work on the strongest branching and merging you can find, and a core that doesn't cringe with huge binaries and repos. We also develop the GUIs, mergetools and everything needed to give you the full version control stack.

If you want to give it a try, download it from here.

We also code SemanticMerge, and the gmaster Git client.

C# Mono performance

Sunday, November 25, 2007 Pablo Santos , 4 Comments

I was reading through some server logs last week when I detected a performance problem. One database query was taking much more time than expected. The strange thing being I was sure I'd double-checked it in the past. I repeated the test in my laptop and the same performance hit showed up (even clearer taking into account the laptop CPU difference with the server).
Ok, just to give you some numbers:
  • The code took about 350ms (.NET 1.1) to execute the query and perform a reader.Read() loop until no more registers were read.
  • It included both reading plus processing time: each row had about 15 fields which were read with reader["myfield"] sentences.
  • The sample retrieved about 5000 rows.

Well, running exactly the same code using Mono the time reached 1800ms!! A huge performance loss!

Last week we were talking about Mono's string handling performance: while it outperforms .NET in integer based tests, it was clearly behind using strings. So I decided to make a obvious change: what if I accessed the data fields using the integer indexer instead of the string based one? I mean myfield = reader[0] instead of reader["myfield"]??

Well, then Mono took exactly the same time as .NET, which is slightly better than its string based counterpart.

So, until the string based operations get a bit optimized, you can count on the good-ol integer indexer to boost Mono based database access.

pablo

Pablo Santos
I'm the CTO and Founder at Códice.
I've been leading Plastic SCM since 2005. My passion is helping teams work better through version control.
I had the opportunity to see teams from many different industries at work while I helped them improving their version control practices.
I really enjoy teaching (I've been a University professor for 6+ years) and sharing my experience in talks and articles.
And I love simple code. You can reach me at @psluaces.

4 comentarios:

Who we are

We are the developers of Plastic SCM, a full version control stack (not a Git variant). We work on the strongest branching and merging you can find, and a core that doesn't cringe with huge binaries and repos. We also develop the GUIs, mergetools and everything needed to give you the full version control stack.

If you want to give it a try, download it from here.

We also code SemanticMerge, and the gmaster Git client.

Exploring visual styles

Thursday, November 22, 2007 Pablo Santos 0 Comments

Today David made a short demo introducing a new Plastic 2.0 graphical user interface alternative. He's been working on different possibilities for the upcoming 2.0 release: from floating (dockable) windows to a more web like rich interface, the one you're previewing today.


The main advantages in the interface are:

  • Full Linux support: some Plastic users have been using the GUI on Linux but it's never reached the same level it has under windows. Now we're finally sure we'll make it for 2.0. The screenshot above (and the ones in flickr) are all made on Linux (Suse/Ubuntu).
  • Multiple views: this is something users (and ourselves internally) have been demanding for the last year. Now you'll be able to show the changes made on a task and explore the history without switching views back and forth. Really useful.
  • A better interface to switch between workspaces: now you'll have all your workspaces available and changing will be easier, and also simpler to notice where you're working on.
  • New views: like, for instance, the long awaited changeset view. You can check the latest changes made to the code base using this view (ok, not only the latest but all of them... :-P).
  • The query system finally available from the GUI: all the views are now customizable, and they all work using the query system: you click on the advanced button and you can inspect or customize the query. Attribute queries get integrated too, so you could do things like showing the branches which are not yet not integrated, created the last week and belonging to the user 'dave'... Customizing your own queries to use them later on is also supported.
  • The code review system gets fully integrated into the new GUI too: now you can trigger it from the branches view, the changeset's one, baselines and so on... Inspecting code or making walkthroughs (something we've been doing using this tool for the last two months already) is now much simpler.

We expect to be publishing a pre-release to be downloaded during the next week, and start gathering feedback about the GUI and server new features...

Pablo Santos
I'm the CTO and Founder at Códice.
I've been leading Plastic SCM since 2005. My passion is helping teams work better through version control.
I had the opportunity to see teams from many different industries at work while I helped them improving their version control practices.
I really enjoy teaching (I've been a University professor for 6+ years) and sharing my experience in talks and articles.
And I love simple code. You can reach me at @psluaces.

0 comentarios:

Who we are

We are the developers of Plastic SCM, a full version control stack (not a Git variant). We work on the strongest branching and merging you can find, and a core that doesn't cringe with huge binaries and repos. We also develop the GUIs, mergetools and everything needed to give you the full version control stack.

If you want to give it a try, download it from here.

We also code SemanticMerge, and the gmaster Git client.

Just for jun, the oldest programming ad I've seen

Friday, November 16, 2007 Pablo Santos 1 Comments

Last week I found a piece of advertisement I found very funny: it was an ad telling readers 23K more programmers were needed each year... and of course becoming one of them was a good idea!
The ad dates back from 1971 and I found it in a very old comic book. I think it is quite nice finding such a reading!

Enjoy!

Pablo Santos
I'm the CTO and Founder at Códice.
I've been leading Plastic SCM since 2005. My passion is helping teams work better through version control.
I had the opportunity to see teams from many different industries at work while I helped them improving their version control practices.
I really enjoy teaching (I've been a University professor for 6+ years) and sharing my experience in talks and articles.
And I love simple code. You can reach me at @psluaces.

1 comentarios:

Who we are

We are the developers of Plastic SCM, a full version control stack (not a Git variant). We work on the strongest branching and merging you can find, and a core that doesn't cringe with huge binaries and repos. We also develop the GUIs, mergetools and everything needed to give you the full version control stack.

If you want to give it a try, download it from here.

We also code SemanticMerge, and the gmaster Git client.

Plastic contributes with One Laptop Per Child

Wednesday, November 14, 2007 mdepedro 0 Comments

We wanted to find a way to collaborate with the One Laptop Per Child initiative. So, for the next 4 days (until Sunday November 18th) for every purchase of Plastic SCM Pro you will be donating $200 to the OLPC project.
Plastic is already free for non commercial projects, so we'd like to make a small contribution for what we consider an excellent initiative.

If you're interested visit http://www.codicesoftware.com/opbuy2.aspx

0 comentarios:

Who we are

We are the developers of Plastic SCM, a full version control stack (not a Git variant). We work on the strongest branching and merging you can find, and a core that doesn't cringe with huge binaries and repos. We also develop the GUIs, mergetools and everything needed to give you the full version control stack.

If you want to give it a try, download it from here.

We also code SemanticMerge, and the gmaster Git client.

Subversion, attributes and random thoughts

Wednesday, November 07, 2007 Ruben , 0 Comments

For the last three weeks I've been involved in the subversion importer development. It will be one the new features for the upcoming 2.0 release. AFAIK plastic will be one of the few commercial tools importing from svn. So I've been fighting against memory problems, performance and some svn features which don't really match with plastic concepts. Hopefully I'll be finishing it this week.

The last two days I started testing the implementation with big real svn repos. Ok, needless to say I made some testing with small ones while I was coding :-). So, it gave me some time to restart some pending tasks from the previous SPRINT. I normally prefer long tasks better than short ones, but having the chance to switch to something different while the big repos was been imported looked like having some fun.

I've been implementing some enhancements to the query system. Last week Borja finished the attributes support so now it was the time to really get the best out of it enabling some queries. So, I've modified the query system introducing the posibility to find objects associated to a certain attribute. Now you can run queries like the following one:


$ cm find branch where attribute = 'status' and attrvalue = 'open'

This one solves one of the most demanded customer requests which is being able to list the branches which are not yet integrated when they follow a branch per task pattern.

It reminds me the 'find merge' command, which I also implemented two months ago and it isn't yet released either.

$ cm find merge where srcbranch = 'br:/main/branch1' and dstbranch = 'br:/main'

This one shows whether there are merges from branch1 to main or not.

Another feature I find useful using attributes is being able to mark certain revisions with some custom comments. I mean not a regular revision comment but something you plug to the revision, for instance to be reviewed later. Imagine you want other developer to review a change you just made, but you're sure you'll be creating new revisions and you want him to check this specific one. Ok, what if you attach a new attribute named 'remark' and you give it a value like 'Must be reviewed'.

$ cm mkatt remark

$ cm statt att:remark rev:src\server\dispacher.cs#br:/main/task001#3 "Must be reviewed"

Now you want to find the revs with this attribute

$ cm find revs where attribute = 'remark' and attrvalue like '%review%'

And it will retrieve the revisions you've marked

All these features will be present in plastic 2.0, which we'll be hopefully releasing quite soon...

0 comentarios:

Who we are

We are the developers of Plastic SCM, a full version control stack (not a Git variant). We work on the strongest branching and merging you can find, and a core that doesn't cringe with huge binaries and repos. We also develop the GUIs, mergetools and everything needed to give you the full version control stack.

If you want to give it a try, download it from here.

We also code SemanticMerge, and the gmaster Git client.

Agile vs corporate decisions

Friday, November 02, 2007 Pablo Santos 1 Comments

It’s been already awhile since the first time I had the chance to check how inefficient some so-called corporate decisions can be.

I was working as a consultant for a well-known company, and giving some training on SCM to its main software development team. Well, at least this is what I was supposed to do. The first morning I arrived there I was introduced to a QA manager and a “quality expert” contractor, the ones who were going to actually receive both the training and “consultancy work”, because the team was “so busy to stop”. Shocking!

I started teaching them basic SCM concepts, then asking them about the way they were working and trying to figure out the best way to move away from their apparently “total chaos” situation. I have to admit that I wasn’t very motivated because I was trying to explain concepts like “branching”, “merging”, “baselines” and the like to people who didn’t seem to have ever managed nor participated in a software development effort. But, ok – I thought – they’re interested to enhance their current situation so let’s try it.

The “funny” thing happened only a few hours later. I was teaching them how to implement some of the concepts and ideas we were discussing using a certain version control package (the whole story happened before Plastic existed) when I unexpectedly discover a shelf full of boxes containing, at least, another two well-known software configuration management packages.

“I see you have licenses for product X and product Y, haven’t you? If so, why are the team still using Visual Source Safe and suffering all the pains you’ve told me?” – I asked.

“Well, you know, I’ve been here to help the team choosing the right SCM tool” – the external consultant (the contractor) answered me – “so I’ve tried first with product X. I’ve received the training myself and then helped the team implement the solution, but the team leader didn’t feel comfortable so I tried with product Y. The team was so busy that I decided to receive the training again and later on try to help them deploying it, but we couldn’t figure out the way to set up an effective working method either so...”

So I was the third one arriving there and trying to move the team away from VSS. But it would be actually impossible if I didn’t have contact (I wasn’t even introduced) with the “real” team. They were big enough to hire people to do the job of selecting the right tools, but they didn’t have the time to listen nor to get involved somehow. The managers didn’t trust the team to decide on which tools would be better for a “company wide solution”, so they hired an “external expert”, the contractor I’ve been talking to. And the team didn’t seem to trust the contractor, so they were in a locked situation.

Everyone seemed to be very busy doing nothing, and this was one of the first times I got in touch with “extreme corporate inability to make any decision”.
Months later I was sent to help starting a pilot project in another big company. They were trying to decide which tool would be the best to use it as “company wide solution”. I was scared (I’m always scared as soon as I hear something starting with “company wide”), and things got even worse as soon as I saw boxes of product X and product W abandoned on a desktop... “No! Not again!” – I thought.
But this time it was a little bit different. This time the problem was not the real team not getting involved, this time the huge problem was setting really unrealistic expectations.

I started with a demo of the product, to show the core functionality and later on moved to find out how to apply it to solve their problems (the demo was required as first step). Then the people there (about 5 different managers) started complaining about the lack of feature XX and feature YY. I was happy to see such an experienced audience (I’m not joking, they seemed very good to me at the moment) discussing about advanced branching patterns, merging topics, how to manage concurrent development, setting up some sort of “streaming” hierarchy to resemble their 3 different environments (development, pre-production and production), and how one of the most advanced tools on the market seemed to be in trouble to actually reach all these expectations.

They explained me how product X and product W failed to meet their needs. Both of them weren’t enough to actually “model” their development process.
They looked so professional and had so strong opinions that I wondered why they were trying to change their current tool. I mean, if they had such a strong development process in place... they should have a really strong SCM system behind!

So I asked them: “Ok, what are you currently using?”

“Er... well, the team is currently using Visual Source Safe” – one of them answered.

I was shocked! A bigger than 250 team using “good-ol” VSS? Unbelievable!

“And “ – I started – “do you actually have this process in place using VSS?”

NO! They weren’t. They had been telling me the way they would like to work, their “desired process” instead of their real one. The “real” one, constrained by VSS limitations, was in big trouble: they avoided merge like hell, suffering huge “blocking periods”, they weren’t able to actually identify which were the binaries in production (they were not managing releases at all, so they didn’t know which sources generated the binaries used by their customer), they didn’t have a good way to do bug fixing (no branch management at all) and they were doing some sort of micro releasing: instead of deploying whole tested released they “uploaded” binaries one by one, which introduced problems more often than not, when different incompatible versions refused to work together.

So they’ve been trying to find the “silver bullet” SCM system for months, discarding really good products, while the whole organization was affected by an important crisis.

Any of the other products they had evaluated was much better than the one they were using. Any!

But they were so busy (or interested, or whatever you call it) trying to find a “company wide solution” that they weren’t able to do any movement.

My advice was: “no matter which one you choose, just choose one! Whatever direction you move will be better than your current situation”.

They were setting so high expectations for the new solutions that no one seemed to fit, but in the meantime they were accepting all the limitations of an obviously suboptimal solution.

Years later I started designing, developing and nowadays deploying Plastic SCM. I have the opportunity to get in touch with a number of companies and see very different situations.

Small companies and some big ones have the ability to download, evaluate and start using Plastic within days or weeks. They make some questions, they make up their minds and then they choose whether Plastic fits or doesn’t fit in their environment. They’re fast. They’re agile decision makers.

But the common feature they have is they’re not too big: whether they’re small companies or teams inside big ones (but with a budget to make their own choices), doesn’t really matter. Size seems to be a key to make fast moves.

Sometimes a team on a corporation decides they’re interested on Plastic. Then they follow the regular process, and when they look like they’re going to buy someone has a bright idea: “what if we scale it to upper management so they can check if we can adopt it company-wide?” And then, more often than not, the situation follows the pattern I described before: someone starts dreaming on all the things an integrated, company-wide, solution should have, taking his time, asking questions, reevaluating already discarded alternatives... wasting precious time! If the team isn’t in a hurry it isn’t a problem, but frequently I see how the lack of agile decision making and searching for a gold-plated-integrated-fully-featured-silver-bulleted solution takes months while the team which had the original problem is still blocked. They can’t make any movement while someone waits for the perfect SCM, when any option (any) would be much better than their present situation.

Being so extremely afraid to make a mistake is a mistake itself. The lost opportunities, the continued deadlocked situation, the impact in the team’s motivation, will be much worse than all the supposed upcoming benefits.
So, each time I hear “company-wide”.... :-D
Pablo Santos
I'm the CTO and Founder at Códice.
I've been leading Plastic SCM since 2005. My passion is helping teams work better through version control.
I had the opportunity to see teams from many different industries at work while I helped them improving their version control practices.
I really enjoy teaching (I've been a University professor for 6+ years) and sharing my experience in talks and articles.
And I love simple code. You can reach me at @psluaces.

1 comentarios: