Programming » Terry's Worklog

Building your own reminder system

C#, Family, Library, Microsoft Comments Off

Apr 252012

One of the hats I wear is as a member of the Independence Library Board. I love it because I don’t work with public libraries as often as I’d like to in my real job, and honestly, the Independence Public Library is the center of the community. The Library is a center for adults looking for education opportunities, kids looking for resources, and home to a number of talented librarians that are dedicated to encouraging a love of reading to our community. It’s one of the few libraries I’ve ever known to have both a children’s and adult reading programs and takes advantage of that in the summer – by having the adults and kids compete against each other to see who logs the most pages (the kids always win).

Each board meeting is interesting, because as the economy became more difficult for people, more people turned to the library. Every month, the library sees more circulations, more bodies in the building, more kids, more adults – just more. And they do it on a budget that doesn’t accurately reflect the impact that they have on the community.

Anyway, one of the things that the Library has going for it is a very active friends program – and through that group (and some grant funds), the library was able to purchase a number of Laptop computers for circulation within the Library. The Library currently has some, 8-10 terminals that are always being used and the laptops would provide additional seats, and allow people to work anywhere within the library using the wifi.

The Library setup the laptops using the usual software – DeepFreeze, etc. to provide a fairly locked down environment. However, what was missing was a customizable timer on the machines. Essentially, the staff was looking for a way to make it easier for patrons checking out the laptops to avoid fines. The Laptops circulate for a finite period of time within the building. Once that time is over, the clock starts ticking for fines. To avoid confusion, and help make it easier for patrons to know when the clock was running out – I’d offered to work on building a simplified timer/kiosk program.

The impetus for this work comes from Access 2007 I think. I had attended the hackfest before the conference and one of the project ideas was an open source timing program. I had worked on and developed a proof of concept that I passed on. And while I never worked on the code since – I kept a copy myself. When we were talking about things that would be helpful, I was reminded of this work.

Now, unfortunately, I couldn’t use much of the old project at all. The needs were slightly different – but it helped me have a place to start so that I wasn’t just looking at a blank screen. So, with idea in hand, I decided to see how much time it would take to whip together an application that could meet the needs.

I’ll admit, nights like tonight make me happy that I still do more than write code in scripting languages like python and ruby. Taking about 3 hours, I put together a feature complete application that meets our specific needs. I’ll be at the Oregon Library Association meeting this week, and if folks find this kind of work interesting, I’ll make it a bit more generic and post the source for anyone that wants to tinker with it.

So what does it do? It’s pretty simple. Basically, it’s an application that keeps time for the user and provides some built-in kiosk functionality to prevent the application was being disabled.

Here are a few of the screen shots:

When the program is running, you see the clock situated in the task tray

Click on the icon, and see the program menu

Preferences – password protected

Because we have a large Hispanic population, all the strings will need be able to be translated. This was essentially is just the locked message. I’ll ensure the others are customizable as well – maybe with an option to just use Google Translate (even though it far, far from perfect) if a need to just get the gist across is the most important.

Run an action (both functions require a password)

Place your cursor over the icon to get the minutes

Information box letting you know you are running out of time

Sample lockout screen

In order to run any of the functions, you must authenticate yourself. In order to disable the lockout screen, you must authenticate yourself. What’s more, while the program is running, it creates a low-level keyboard hook to capture and pre-process all keystrokes, disabling things like escape keys, the windows key, ctrl+alt+del so that once this screen comes up – a user can not break out of it without shutting off the computer (which would result in needing to log in). Coupled with DeepFreeze and some group policy settings, my guess is that this will suffice.

The source code itself is a few thousand lines of code, with maybe a 1000 or 1500 lines of actual business logic and the remainder around the UI/threading components. Short and simple.

Hopefully, I’ll get a chance to do a little testing and get some feedback later this week – but for now – I’m just happy that maybe I can give a little bit back to the community library that gives so much to my family. And if I hear from anyone that this might be of interest outside my library – I’ll certainly post the code up to github.

–TR

Getting the real %windir%\system32 directory from within a 32 bit process on a 64 bit machine

C# Comments Off

Mar 082011

When working with the 64-bit flavor of Windows, there are a couple of quirks that you just need to accept. First, when Microsoft designed windows for 64 bit processing, they weren’t going to break legacy applications and second, how this gets done makes absolutely no sense unless you simply have faith that the Operating System will take care of it all for you.

So why doesn’t it make sense? Well, Windows 64-bit systems are essentially operating systems with two minds. One the one hand, you have the system designed to run 64-bit processes, but lives within an ecosystem where nearly all windows applications are still designed for 32-bit systems. So what is an OS designer to do? Well, you have both versions of the OS running, obviously. Really, it’s not that simple (or complex) – in reality, Microsoft has a 32 bit emulator that allows all 32 bit applications to run on 64-bit versions of Windows. However, this is where it gets complicated. Since 64 bit processes cannot access 32 bit processes and vise versa – you run into a scenerio where Windows must mirror a number of systems components for both 32 and 64 bit processes. They do this two ways:

In the registry – Microsoft has what I like to think of as a shadow registry that exists for WOW64 bit processes (that’s the 32 bit emulator if you can’t tell) – to register COM objects and components accessible to 32-bit applications.
The presence of a system32 (this is ironically where the 64bit libraries live) and a SysWow64 (this is where the 32 bit libraries live) system folders which replicate large portions of the Windows API and provide system components for 32-bit and 64 bit processes.

So how does this all work together? Well, Microsoft makes it work through redirection. Quietly, transparently – the Windows operating system will access the applicable part of the system based on the process type (being either 64 or 32 bit). The problem arises when one is running a 32-bit process, but want to have access to a dedicated 64 bit folder or registry key. Because redirection happens at the system level, programming tools, api access, etc. all are redirected to the appropriate folder for the process type.

Presently, I’m in the process of rebuilding MarcEdit, and one of the requirements is that it run natively in either 32 or 64 bit mode. The problem is that there are a large cohort of users that are working with MarcEdit on 64 bit systems, but have it installed as a 32 bit app. So, I’ve been tweaking an Installer class that will evaluate the user’s environment (if 32 bit process running in a 64 bit OS) and move the appropriate 64 bit files into their correct locations so that when they run the program for the first time, the C# code compiled to run on Any CPU (so, if it’s a 64 bit OS, it will run natively as a 64 bit app) – the necessary components will be available.

So how do we do this? Actually, it’s not all that hard. Microsoft provides two important API for the task: Wow64DisableWow64FsRedirection and Wow64RevertWow64FsRedirection. Using these two functions, you can temporarily disable redirection within your application. However, you want to make sure you re-enable when your required access of these components is over (or apparently, the world as we know it will come to and end). So, here’s my simple example of how this might work:

#region API_To_Disable_File_Redirection_On_64bit_Machines
public static string gslash = System.IO.Path.DirectorySeparatorChar.ToString();
[DllImport("kernel32.dll", SetLastError = true)]
private static extern bool Wow64DisableWow64FsRedirection(ref IntPtr ptr);
[DllImport("kernel32.dll", SetLastError = true)]
private static extern bool Wow64RevertWow64FsRedirection(IntPtr ptr);
#endregion

#region Fix 64bit 
if (System.Environment.Is64BitProcess == false && System.Environment.Is64BitOperatingSystem == true)
{
//This needs to have some data elements moved from the 64bit folder to the System32 directory
try
{
string[] files = System.IO.Directory.GetFiles(AppPath() + "64bit" + gslash);
string windir = Environment.ExpandEnvironmentVariables("%windir%");
string system32dir = Path.Combine(windir, "System32");
if (system32dir.EndsWith(gslash) == false) {
system32dir += gslash;
}

//We need to run off the redirection that happens on 64 bit systems.
IntPtr ptr = new IntPtr();
bool isWow64FsRedirectionDisabled = Wow64DisableWow64FsRedirection(ref ptr);
foreach (string f in files)
{
try
{
string filename = System.IO.Path.GetFileName(f);
if (System.IO.File.Exists(system32dir + filename) == false)
{
    System.IO.File.Copy(AppPath() + "64bit" + gslash + filename, system32dir + filename);
}
}
catch (System.Exception yyy){//System.Windows.Forms.MessageBox.Show(yyy.ToString()); 
}
}
//We need to run the redirection back on
if (isWow64FsRedirectionDisabled)
{
bool isWow64FsRedirectionReverted = Wow64RevertWow64FsRedirection(ptr);
}

}
catch
{}
}
#endregion

And that’s it. Pretty straightforward. As noted above, the big thing to remember is to Reenable the Redirection. If you don’t, lord knows what will happen.

–TR

Elevating a process to running an MSI from a standard user’s account

C# Comments Off

Mar 022011

One of the questions that consistently comes up with the advent of Windows Vista and Windows 7’s use of the UAC is how to run applications or processes without being prompted for a username/password. There are a number of places online that talk about how to use the C# classes + LogUser API to impersonate a user. In fact, there is a very nice class written here that makes it quite easy. However, these options don’t work for everything – and one specific use case is during installation. So, for example, you’ve written a program and you want to provide automatic updating through the application. To do the update, you’d like to simply shell to an MSI. Well, there is a simple way to do this. Using the System.Diagnostics assembly you can initiate a new process. So, for example:

System.Security.SecureString password = 
                      new System.Security.SecureString();
string unsecured_pass = "your-password";
for (int x = 0; x < unsecured_pass.Length; x++)
{
  password.AppendChar(unsecured_pass[x]);
}
password.MakeReadOnly();
StringBuilder shortPath = new StringBuilder(255);

GetShortPathName(@�?c:\your file name.msi�?, shortPath, 
                 shortPath.Capacity);
System.Diagnostics.ProcessStartInfo myProcess = 
                 new System.Diagnostics.ProcessStartInfo();
myProcess.Domain = "my-domain"; 
myProcess.UserName = "my-admin";
myProcess.Password = password;
myProcess.FileName = "msiexec";
myProcess.Arguments = "/i " + shortPath.ToString();
myProcess.UseShellExecute = false; 
System.Diagnostics.Process.Start(myProcess);

So, using the above code, a program running as a standard user, could initiate a call to an MSI file and run it as though you were an administrator. So, why does this work? First, in order for this type of elevation to work, you need to make sure that UseShellExecute is set to fall. However, if you set it to fall, you cannot execute any process that isn’t an executable (and a .msi isn’t an executable). So we solve this by calling the msiexec program instead. When you run an msi installer, this is the parent application that gets called. So, we call it directly. Now, since we are calling an executable, we can attach a username/password/domain to the process we are about to spawn. This allows use to start the program as if we were another user. And finally, when setting the path to the MSI file we want to run, we need to remember that we have to call that file using the Windows ShortFile Naming convention. There is an API that will allow you to accomplish this.

If you have this setup correctly – when the user runs an MSI file, they will not be prompted for a username or password – however, they will still see a UAC prompt asking to continue with the installation. It looks like this (sorry, had to take a picture):

So, while the user no longer has to enter credentials to run the installer, they do have to still acknowledge that they wish to run the process. But that seems like a livable trade off.

–TR

WorldCat API gem moved to rubyforge

OCLC, rails, ruby Comments Off

Mar 132009

I had mentioned that I’d quickly developed a helper gem for simplifying using the WorldCat API in ruby (at least, it greatly simplifies using the API for my needs). This was created in part for C4L and partly because I’m moving access from Z39.50 to the API when working with LF and I basically wanted a be able to do the search and interact with the results as a set of objects (rather and XML).

Anyway, the first version of the gem (which is slightly different from the code first posted prior to C4L) can be found at the project page, here: http://rubyforge.org/projects/wcapi/

–TR

WorldCat API: draft ruby gem

OCLC, ruby 1 Response »

Feb 222009

Since the WorldCat Grid API became available, I’ve spent odd periods of time playing with the services to see what kinds of things I could do and not do with the information being made available. This was partly due to a desire to create an open source version of WorldCat Local. It wouldn’t have been functionally complete (lacking facets, some data, etc), but it would be good enough, most likely, for folks wanting to switch to a catalog interface that utilized WorldCat as their source database, rather than their local ILS dbs. And while the project was pretty much completed, the present service terms the are attached to the API make this type of work out of bounds at present (though, I knew that when I started – it was more experimental with the hope that by the time I was finished, the API would be more open).

Anyway…as part of the process, I started working on some rudimentary components for ruby to make processing the OCLC provided data easier. Essentially, creating a handful of convenience functions that would make it much easier to call and utilize that data the grid services provided – my initial component was called wcapi.

Tomorrow (or this morning if you are in Providence), a few folks from OCLC will be putting on a preconference related to the OCLC API at Code4Lib. There, folks from OCLC will be giving some background and insight into the development of API, as well as looking at how the API works and some sample code snippets. I’d hoped to be there (I’m signed up), but an airline snafu has me stranded in transit until tomorrow – so by the time I get to Providence, all of, or most of the pre-conference will be over. Too bad, I know. Fortunately, there will be someone else from Oregon State in the audience, so I should be able to get some notes.

However, there’s no reason why I can’t participate, even while I�?m jetting towards Providence – and so I submit my wcapi gem/code to the preconference folks to use however they see fit. It doesn’t have a rakefile or docs, but once you install the gem, there is a test.rb file in the wcapi folder that demonstrates how to use all the functions. The wrapper functions accept the same values as the API – and like the API, you need to have your OCLC developer’s key to make it work. The wcapi gem will utilize libxml for most xml processing (if it’s on your machine, otherwise it will downgrade to rexml), save for a handful of functions that done use named namespaces within the resultset (this confuses libxml for some reason – though their is a way around it, I just didn’t have the time to add it).

So, the gem/code can be found at: wcapi.tar.gz. Since I’ll likely make use of this in the future, I’ll likely move this to source forge in the near future.

*******Example OpenSearch Call*******

require ‘rubygems’
require ‘wcapi’

client = WCAPI::Client.new :wskey => ‘[insert_your_own_key_here'

response = client.OpenSearch(:q=>'civil war', :format=>'atom', :start => '1', :count => '25', :cformat => 'mla')

puts "Total Results: " + response.header["totalResults"]
response.records.each {|rec|
puts "Title: " + rec[:title] + "\n"
puts "URL: " + rec[:link] + "\n"
puts "OCLC #: " + rec[:id] + "\n"
puts "Description: " + rec[:summary] + "\n"
puts "citation: " + rec[:citation] + "\n"

}

********End Sample Call****************

And that’s it. Pretty straightforward. So, I hope that everyone has a great pre-conference. I wish that I was there (and with some luck, I may catch the 2nd half) – but if not, I’ll see everyone in Providence Monday evening.

–TR

LibraryFind 0.8.5.8 next week

LibraryFind, ruby 1 Response »

Dec 082008

As I’ve been working on 0.9, I’ve been trying to migrate few odds and ends into the current 0.8 branch so that I can move them into production faster on our end. To that end, I’ll be posting an updated to LF by the beginning of next week. These updates will include:

Update to the Harvester (this will make it a bit more fault tolerant) as well as allowing harvesting of sets (currently) and root level oai providers (not provided currently). This change required significant changes to the search component as well that deals with the harvested materials.
Auto-detection of namespaces (for oai and sru — needed for libxml)
Removed rexml dependencies for opensearch component
Frozen gems for oai, sru and opensearch into vendor directories (and have added that to the environment.rb file)
Prep code for solr/ferret decision. I’ll be adding support to use either ferret or solr as your backend indexer for harvesting for 0.9, but some changes are being made to make this easier. Ferret provides an integrated rails solutions, while solr would provide a hosted index option.
In addition to this, some changes to the libxml module have deprecated a call being used in the oai gem (maybe the sru gem). I’ll take a look at both this week and update appropriately [as well as keep backworks compatibility if possible]

Something else, we are starting to work with mod_rails. This allows apache to manage the rails environment — eliminating the need to run rails through packs of mongrels (or other specialized serving mechanism). I’ll write up something on our experiences for others that might be interested in this approach.

–TR

What would it look like if OCLC was broken up?

Digital Libraries, OCLC, Programming 5 Responses »

Nov 032008

The other day, I posted what I seen as some very big concerns with OCLC’s revised policy (currently being reconsidered) on the transfer of records (two of which, I would consider deal breakers). In this post, I made the argument that maybe it was time to consider breaking OCLC up to reflect what it has become — an organization with two distinct facets: a membership component and a vendor component. This comment led to a conversation from someone at OCLC who questioned whether I honestly believed that the library community would be better off if OCLC was broken up and it was obvious from our conversation that on this point, we would simply need to agree to disagree. As a side note, I think that these types of disagreements and conversations are actually really important to have. I’m always nervous of communities or groups in which everyone agrees since it usually means that people either are not thinking critically or no really cares. Secondly, I think that we all (OCLC and myself for that matter) want what’s best for the library community — we just have different visions of what that might be.

Anyway, back to my topic. Now, I’m going to preface this discussion by saying that this is obviously my own opinion and one that may not be shared by many people within the library community (I really have no idea). Even within the library open source community, where I’m sure this opinion would be more prevalent (or at least entertained), I’m pretty sure I’m still in the minority. But as I say, I think that these conversations are important to consider — specifically as we move down a path where OCLC is very quickly positioning themselves to become the library community’s default service provider for all things library (in terms of ILL, ILS interface, cataloging, etc.).

So when I talk about breaking up OCLC, exactly what am I’m talking about? Well, in order to follow me down the path that I am going to take you, we have to talk about OCLC as I currently see them. Watching OCLC during the 10 years (I can’t believe it’s actually been 10 years) that I have been in libraries, I have seen a quickening evolution of OCLC from strictly a member driven organization to more of a hybrid organization. On the one hand, there is what many would consider the membership side of OCLC, that being WorldCat, ILL and their research and development office. On the other hand, there is OCLC’s vendor arm…a good example of this would be WorldCat Local and WorldCat Navigator. So how do I make these distinctions — membership services are those that I would consider core services. These are services that OCLC has developed to add value to what OCLC likes to refer to as the Library Commons (WorldCat). OCLC’s vendor services are those tools or programs that OCLC sells on top of the Library Commons, of which, I think WorldCat Local/Navigator is a good example. Now I think that at this point, I know that folks at OCLC (and likely in the membership) would argue that both WorldCat Local/Navigator do provide services that the OCLC membership is currently requesting. I won’t deny that — however, I would answer that the fact that OCLC treats the Library Commons (WorldCat) as it’s own closed personal community has the unintended affect of limiting the library community’s (and I include both commercial and non-commercial entities in my definition of community) ability to develop new service models. In effect, we become much more dependent on how OCLC envisions the future of libraries. Let me try and tease this out a little bit more…

Philosophically, the biggest problem that I have with the current situation is the commingling of OCLC’s treatment of the Commons (WorldCat) and their current strategy of being the sole commercial entity with the ability to interact with the Commons. I’m a firm believer that the more diverse the landscape or ecology, the more likely that innovation will take place. We’ve seen this time and time again both inside (Evergreen and Koha certainly have shaken up the traditional ILS market) and outside (web browsers are a good example of how competition breeds innovation) the library community. However, by isolating the Commons, OCLC is threatening this diversity of thought. Now, I have a whole set of different issues with the current library ILS community, but in this case, I think that OCLC’s treatment of the Commons, and their ability to leverage that service unfairly skews the ability for both commercial and non-commercial entities to provide innovative services on top of those Commons (and before anyone jumps on me for non-commercial use, let me finish my thoughts here). Commercially, I’m fairly certain that the current crop of ILS vendors would very much like to provide their own WorldCat Local/Navigator interfaces to their customers, and I’m sure, would be able to tie these interfaces closely with services already provided by the users ILS. I could envision things like ERM (electronic resource management), simplified requesting, etc. all being possible if the likes of ExLibris or Innovative Interfaces were allowed to build tools upon the Library Commons (WorldCat). Maybe I would like to develop my own version of WorldCat Local/Navigator that interacts with the Commons and sell it as a product (kind of the same way ezproxy was sold prior to being acquired by OCLC) or a group of researchers would like to do the same. As a commercial entity, I’m fairly certain that this type of development model wouldn’t be kosher with OCLC unless I licensed access to WorldCat (and I’m not certain that they would given that this would compete against one of their services). Likewise, open source folks like LibLime or Equinox may like to create an open source version of the WorldCat Local interface. Under the current guidelines, I understand that an open source implementation of WorldCat Local can exist — but as I understand that agreement, I’m not certain that groups like LibLime or Equinox (or another entity) could not take that project and then sell support-based services around it (I’m unclear on that one though). However, it’s very unlikely that the library world will see any of these types of developments (well, maybe the open source WorldCat Local since I have a group that could use this and a number of people interested in developing it) because OCLC has come to treat what it calls the Commons (WorldCat), as it’s own personal data store. There’s that commingling again.

So if it was up to me, how would I resolve this situation? Well, I see two possible scenarios.

Open up WorldCat. OCLC likes to refer to WorldCat as the Library Commons — well, let’s treat it as such. Remove the barriers for access and allow anyone and everyone the ability to essentially have their own copy of the Library Commons and it’s data. Now, rather than specifying terms of transfer and telling libraries under what conditions they can and cannot make their metadata available to other groups, the membership could consider what type of Open Data license that the Commons could be made available under. Something like the creative commons share alike license which allows for both commercial and non-commercial usage, but requires all parties to contribute all changes to the data back to the community (in essence, this is kind of what Open Library is doing with their metadata) may be appropriate. OCLC would be free to develop their own products, but the rest of the library community (both library and vendor community) would have equal opportunity to develop new services and ways of visualizing the data found in the Commons. Does this devalue the Commons (WorldCat)? I don’t think so — look at Wikipedia. It uses this model of distribution, yet I’ve never heard anyone say that this devalues it’s content. Would there be challenges? For sure. Probably one of the biggest would be the way that it would change what it means to be a member of OCLC. If each person could download their own personal copy of the Commons, would libraries stay members. I’m certain that they would — but I’m sure that what it means to be a member would certainly change.
Split OCLC’s membership services from OCLC’s vendor services. Under this example, WorldCat Local/Navigator development would be spun away from OCLC as a separate business (this happens in academia all the time). Were this to happen, OCLC would be able to develop terms for license that could then be leverage by all members of the commercial library community removing the artificial advantage OCLC is currently able to leverage (both in terms of data and deciding who is allowed to work with the Commons). In all likelihood, I think that this model likely represents the smallest change for the membership and would continue to allow OCLC to make the Commons more available to non-commercial development without artificially limiting other groups interested in building new services.

One last thought. In talking to people today, I heard a number of times that OCLC restricting access to the Commons was in fact good thing, in part, because it finally allowed the library community the ability to leverage resources not available to the vendor communities. In some way, we could finally stick it to them. That’s fine, I’m all for developing tools and services, but this particular type of thinking I find worrisome. If we, as a community, feel that we are unable to develop compelling tools and services that are able to compete with other vendor offerings without an artificial advantage — well that’s just sad and says a little something about how we see ourselves as a community. And this too is something that I’d like to see change because if you look around, you will see that there are a myriad of projects (Koha, Evergreen, VuFind, Fedora, DSpace, LibraryFind, XC Catalog, Zotero, etc.) where developers (some library developers, some not) are re-envisioning how they see many of the services within the library and putting their time and effort into realizing those visions.

–TR

Must the library live in perpetual beta to achieve agility

MarcEdit, Programming, Readex 1 Response »

Oct 082008

An interesting question brought up by David Seaman here at the Readex Digital Institute. David provided the opening keynote for the conference and in it, discussed a process that Dartmouth College went through this year to consider how the library can become more nimble within our networked world. How the library can be given a license, if you will, to allow the library to release services that aren’t perfect and are iterative in their development cycle. And while I can certainly get where David is coming from, I don’t think that the logical outcome is a service model that lives within perpetual beta.

I think that part my objection to this phrase comes from my development background. As a developer, I’m a firm believer in a very iterative approach to development. Those that use MarcEdit can probably attest (sometimes to their dismay) that updates can come with varying frequency as the program adapts to changes within the metadata community. Since MarcEdit doesn’t follow a point release cycle in the traditional sense, could it be a beta application? I guess that might depend on your definition of beta — as it certainly would seem to meet the criteria that Google applies to many of it’s services. However, there is a difference I think. While I take an iterative approach to development, I also want to convey to users that I will support this resource into the future and as beta, that’s not the case. My personal opinion is that services that languish in beta are doing two things:

telling users that these services are potentially not long-term, so they could be gone tomorrow
giving users a weak apology for the problems that might exist in the software (and deflecting blame for those issues, because hey, it’s beta).

So, I don’t see this as the road to nimble development. Instead, when I heard David’s talk, I heard something else. I believe libraries fail to innovate because as a group we are insecure that our users will leave us if we fail. And when I hear talks like David’s, that’s what I’m hearing his organization say. They are asking the library administrators for permission to fail, because what is technological research but a string of failures in search for a solution. We learn through our failures, but I think that as a community, our fear of failing before our users can paralysis us. The fear of failing before an administration that does not support this type of research and discover can paralysis innovation by smart, energetic people within an organization. A lot of people, I think, look at Google, their labs, their beta services and say, yes, that is a model that we should emulate. But they don’t fully understand I think that within this model, Google builds failure as an acceptable outcome into their development plan. If libraries want to emulate anything from the Googles or the Microsofts of the world, they should emulate that and engender that type of discovery and research within their libraries.

I am actually very fortunate at Oregon State University in that I have a director and an administration that understands that for our library to meet the needs of our users now and in the future, we cannot be standing still. And while the path we might take might not always be the correct one, the point is that we are always moving and always learning and refining our understanding of what our users want today and tomorrow. What I’d like to see for David’s library is that kind of environment — and I wish him luck in it.

–TR

oai and sru gems updated

rails, ruby Comments Off

Sep 192008

In wrapping up the Libraryfind 0.8.5.1 update, I’ve had to make some modifications to a few gem packages. These are the ones updated:

oai: http://rubyforge.org/projects/oai/
Changes:
Prior versions of the oai component only supported the ruby libxml gem 0.3.8-. In order to support the newer versions of the ruby-libxml (which does better memory management), I’ve updated the oai gem that will support both the older and new ruby-libxml apis. The primary changes are related to how it handles properties/attributes and the way that the oai provider class handles dates (to support OAI 2.0 validation).
sru-ruby: http://rubyforge.org/projects/sru/
Changes:
Added libxml support. For queries that return one or two records, the different between using REXML or Libxml as your parser will be hardly noticable. However, when queries result in larger datasets, the difference will be measured in terms of seconds. For example, in some tests, recordsets returning 50 records in MARCXML format could run close to 10 seconds using REXML. On the other hand, the same search using libxml processes in 0.8 seconds. For tools, like LibraryFind, which deal with larger datasets, this is a welcome change.

–TR

Rails SVN question

rails 1 Response »

Feb 242008

For a rails project, when I want to update the vendor/rails it appears that the easiest way to update this in svn is to delete the directory, refresh the gems and then re-add the directory to the svn. Does this sound right? Seems like it should be easier. This has been the process that we have used for about a year and after going through it again (to update to the 2.0.2 framework), I’m just thinking that its got to be easier.

–TR

Older Entries