Occasionally I am asked to explain the difference between groups and folders in Together. I might be able to boil this down for the FAQ, but here is a full explanation.

Together has two ways of collecting files together, groups and folders. In a nutshell, folders work the same as in the Finder, while groups work like iTunes playlists.

Groups were introduced in version 1.0 to support the point of Together, in that you do not need to file items into folders because they always appear in your library. Folders were added to version 2.0 because sometimes the folder structure is important to the files being stored and because some people were accustomed to that way of working.

Folders

Folders in Together work exactly like folders in the Finder, and that’s exactly what they are. A file can only exist in one folder at a time, adding a file to that folder moves it there and removing a file from a folder moves it to Together’s Trash and removes it from Together’s library and any groups or smart groups. Removing the folder moves the folder and its entire contents to the Trash.

Groups

Groups work like iTunes playlists and are very different to folders. Groups cannot be arranged hierarchically. A file can appear in more than one group at a time. Adding a file to a group adds a reference to that file, and removing a file from a group or removing the group itself doesn’t change anything else. Groups will always keep track of files, no matter where they are stored.

Using Groups and Folders

How you want to use these is up to you. Folders, as mentioned, are good when you want or need to organize files hierarchically, while groups allow you to create loose collections and removes the limitation of only being able to see a file in a single place. You can’t mix groups and folders in a hierarchy because they’re pretty incompatible in terms of what is stored where.

Groups are ideal for research, where you can collect a number of documents from different locations into once place, without moving the files from their original locations. Once you’re finished with the group, you can just remove it without removing any of the files it contains.

Any developer will tell you that no application can remain simple for very long. This is good as further development of the application through ideas and requests means that the application can grow with a receptive audience. The difficult part is determining how.

Some applications suffer this problem more than others. The most dangerous aspect of this for a developer is to introduce something that becomes a problem, and in the worst case, a millstone around their neck. It’s not easy to remove features, even if they are problematic. Likewise, insufficiently implemented features will generate more work in support requests than they took to add in the first place. The key to keeping this manageable is to work within the scope of the application.

My two applications are oceans apart in this respect. Both have grown in ways I could never have imagined, but none more than Feeder. It started as a fairly straightforward RSS reader, but then became involved in the anything-but-simple world of podcasting. Now it’s an RSS editor, an audio / video file tagger and FTP client all wrapped up in one package.

And yet, on the surface, Feeder hasn’t changed much at all. Someone who bought the 1.0 version for creating a standard RSS feed won’t feel like the app has become something different or unsuitable. The features have integrated seamlessly because they are right for the application. There are many requested features that didn’t make the cut, and I’m satisfied that those decisions proved correct over time.

Together’s potential scope is much broader than Feeder’s to the point that I am still implementing features I thought of four years ago. On seeing the app, people have many ideas about what it should do or be. In the two months since Together’s 2.0 release I have done little more than answer emails and during that time have collected over 100 valid feature requests, filtered through what I see as the scope of the application.

Together’s scope is no different to version 1.0 and that is to store, organize, preview and search files as elegantly and efficiently as possible. In time, the scope might expand without detracting from the fundamental nature of the application, but for now, with strong demand for features that will likely take years to fully realise, there is far too much to be done. Of course, these features cannot be added all at once. People expect regular updates, so each release will prioritise the most needed requests.

Interest in Together has been so great as to be overwhelming. Even with all the work put into the 2.0 version, the potential for the application is huge and some people will be happier with its progress than others. Thankfully, there are lots of options out there, so there should be something for everyone. Obviously, I can’t keep sprinting on the support treadmill, so I’ve set up the forums and placed much more emphasis on the FAQs to try and bring the situation back under control.

As I mentioned when I announced the application, version 2.0 sets the platform from which the app will grow over the next few years. Some things are going to take time, but the future for Together looks very promising, not least thanks to everyone who has supported and contributed to Together and KIT so far. The 2.x series is shaping up to be very exciting indeed.

This is a slightly more obscure tip, but since I’ve been asked it a couple of times I thought it was worth posting.

If you work with source code, you may have seen the Quick Look plugin, QLColorCode. Together provides rudimentary editing of source code files, but with no syntax coloring. This means you will see Together’s built-in editor rather than a Quick Look preview when viewing source code files.

There is a way around this though, and that’s to disable Together’s source code editor. Right now you can’t do this in the app, you have to set a hidden preference in Terminal. First, quit Together, then enter the following line in Terminal:

defaults write com.reinvented.Together TRExcludedPlugIns -array-add com.reinvented.TRSourceCodePlugIn

The next time you launch Together, you should see source code files as Quick Look previews from the QLColorCode plugin.

To enable the Source Code plugin again, quit Together and use this command in Terminal:

defaults delete com.reinvented.Together TRExcludedPlugIns

It’s that time of year again! As you may already know, MacSanta is running through the month of December and works slightly differently to last year. Every day, 5 new developers are revealed to offer 20% off their applications.

Today it’s RealMac Software (RapidWeaver), Twisted Melon (Mira, Manta TR1), Loghound Software (RapidBlog, FaqMaker and more), Helium Foot Software (Mercury Mover) and, of course, your very own Reinvented Software, with both Together and Feeder.

To save 20% on the full price, enter the discount code MACSANTA07 when you check out. The 20% discount is only available for one day. After that, you can still save 10% on the full price versions using the code MACSANTA07TEN on any of the deals featured so far until the end of the year.

New software is added every day so it’s worth keeping an eye on the site or subscribing to the RSS feed. I find it’s also a great place to discover software you never knew existed. Enjoy!

As mentioned previously, I am committed to making Together perform really well, including with large libraries, as this is a common complaint from some people about apps of this sort (or so I keep hearing). As I find out about individual performance problems, I’m fixing them. It’s quite a challenge, people make incredible demands of these sorts of applications.

As I see it, the top priority here is to have Together perform well in everyday operations and it does, although I’ll mention some more improvements coming in that area below.

However, some people have criticised Together’s performance in importing a large number of files (anything from 5,000 to 20,000), so I’ll try to explain the problem here and give some tips on how to do that quickly and successfully.

Importing Large Numbers of Files

Together imports files in the background. This is useful for a number of reasons, not least as a way for you to use the Shelf without blocking the app with a progress sheet, and to keep the Shelf compatible with Spaces (showing a progress sheet on a window automatically makes that window’s space active, which is a real pain when you’re working in another application).

This background importing is also good because it means you can continue to work in the application while files are imported. However, there’s a downside in that, for every file added to the library, Together has to sort the list of files.

If the Library group (which shows all the files in Together) is selected and it already contains thousands of items, the second or so that it takes to sort the items adds considerably to the time it takes to import 10,000 files. And the more files there are in the library, the longer it will take to sort them. As such, large imports will get progressively slower.

There’s an easy answer to this: select a group or folder that is not affected by the large import and therefore doesn’t have to sort the incoming files. Using this method, I’ve imported 10,000 items in about 30 minutes, which is how long it took to copy them in the Finder.

In general, this is not an issue. How often do you import thousands of items a time? It’s typically a one-off operation performed when first using the software and most people don’t do it at all. That some people’s impression of the software is formed through this is unrepresentative and unfortunate. I can understand why they would feel frustrated.

Performance vs. Responsiveness

There is also the matter of performance vs. responsiveness. I have some changes lined up for the next version of Together in this area.

To give an example, somebody wrote to me yesterday to say that they got the spinning beachball when switching between some groups, but not others. It turns out the the first item in the slow group was an 8 megabyte PDF file (equates to about 200 pages). So, once the group was selected, Together would immediately start loading that PDF. Try opening an 8MB PDF in Preview and see how long it takes before it’s ready for you to start working with it.

In Together, most previews are loaded in the background and then displayed. This makes the app appear more responsive (i.e. you could scroll through many items or switch groups without a lag), but you don’t see the preview any quicker. Together also caches previews of some files so it’s quicker to revisit them.

I try to avoid these measures when possible because the background loading actually makes the app slower for some kinds of files and the caching increases the memory footprint (if you use too much memory, that will also slow the app down), but I will be taking this approach for large PDF files in the next version.