technorabble

Norabble Moved to Substack

ryan.technorabble@gmail.com (Ryan Baker) — Fri, 01 May 2026 20:41:00 +0000

For the last year, I’ve been writing on Substack, at https://substack.norabble.com. I should have mentioned this change a while ago, but the upside is that I’ve now got 35 new articles on Substack to introduce you to.

The new topics over there have been a thread about money and trust:

A thread about Abundance:

A thread about AI in general:

Another thread about AI and economics

A thread on AI and security:

A thread on AI and software control:

Hope to see you over there! Free subscriptions have full access, any paid subscription is to voluntary support.

Scientific Research Funding

ryan.technorabble@gmail.com (Ryan Baker) — Mon, 24 Apr 2023 05:01:00 +0000

Funding of Scientific Research is one of those questions where almost everyone agrees there's a problem. I have this impression that research funding processes are often an obstacle, either by making the wrong decisions, or by adding too much friction by the process of decision making. That's not a reflection so much on the people making the decisions.

In theory, yes, if the decision makers were perfect, then the current system would be close to perfect too. But perfection is an unreasonable standard, and the better question is whether the decision makers are the best available.. and in that case I have a reasonable amount of confidence that we're at least close to that standard, and so focusing on who's making the decisions (other than continuing to try to keep up standards) would not produce a lot of extra results. Instead, it's changes in the process that offers more realistic opportunities for improvement.

What improvements do I think of? I look at the current system as fairly command and control. Funding organizations attempt to evaluate proposals directly, with the view that they will always make the best decisions, if they get all the information. One of the theoretical problems with that is how it degrades as perfection recedes. Not all information will be available, and even if the decision makers are the best individuals to evaluate this wide variety of information, absorbing it all is difficult. That's not the end of it though, as there are biases introduced via those limitations, in that certain proposals will have greater difficulty presenting all information, or making that information consumable by decision makers, and those difficulties may have little to do with the value or viability of the proposal.

I think of this as similar to the trade-off between a command and control economy and a capitalistic one. Now, in a sense, capitalism itself is sometimes the remedy to those gaps, but capitalism has a big gap of its own when it comes to research, in that capitalism only rewards those research advances for which the value of them can be captured by a company with the rights to that value. When the actual value ends up dispersed throughout society, the rewards system of capitalism breaks down and the best outcome is no longer incentivized. A company founder must be altruistically oriented to pursue that, as well as everyone who funds that company all the way through initial funding to banks and stock market participants. While idealists do found companies sometimes, their probabilities of success decline when they don't have the support of all those other elements.

So, I like the idea of introducing a funding mechanism that recognizes idealist motivations, and doubles down on them. One thing nice about idealists is they are less concerned with their own wealth, and more concerned with what they accomplish. That doesn't mean they can totally ignore those other systems if they live in a society in which the two forms of funding are venture capital, and decision making committees.

I think you could do this by giving researchers a "research capital" budget, rather than looking at individual projects in detail (obviously, could still do both with different mixes of money). In this system, a researcher could draw from a research budget that is based upon the value of prior research successes, credentials, or committee decisions. It's that first one "research successes" that would be the most fundamentally different and the main driver of this system.. the second and third are more of a bootstrap method so that there is a door into this system for new researchers.

Defining research successes would fall back into a bureaucratic evaluation, as I see no other way to assess uncaptured value from research that's so common to basic research.

In a way, you might ask, why provide a "research budget" instead of simply providing cash? One of the main reasons is that cash brings many bad motivations, and we'd then expect there to be many more attempts to defraud committees responsible for this type of evaluation. A second is that every time a fraud did happen, it would undermine public support more if it was seen that the money got used for personal consumption rather than on research. Of course, there's still the possibility that fraud happens within research, where what is said to be spent on research is spent on personal consumption.. but one more layer makes it a bit less likely.

Another reason not to provide cash, is that it's unnecessary to do so if researchers are motivated by ideals. While you might miss out on some people without that type of motivation, or some mix of that motivation, there's still the capitalist system out there (with its flaws) for them. It's better, in my mind at least, to make the best possible system for the idealists, than to compromise on that aspect to try and pull in those whose personal motivations are already more drawn toward a capitalistic system.

Ag 3.0.. why not 4.0?

ryan.technorabble@gmail.com (Ryan Baker) — Tue, 04 Aug 2015 04:26:00 +0000

Since David Roberts departure from Grist, Nathanael Johnson is at the top of my list of Grist authors. An article today clued me into a discussion over "Ag 3.0" going around.

I have a vision of a future of farming that goes small in the way "Ag 2.0" went big. If data is 3.0, then I'd call this 4.0. It's not quite here yet, but the capabilities are. Farming machinery has become larger and larger because it's designed around one primary concern, human productivity. For one farmer farm more acres, he needed a bigger and bigger machine, because he could only sit in one driver's seat at a time.

The future though is bringing autonomous devices, which will take us back in the opposite direction in many cases. Sometimes big is more efficient, but often times it's a blunt instrument performing surgery. As farming tech trends back toward the small all kinds of missed out opportunities become possible. Plants can be commingled in fields to support each other nutrient wise (nitrogen fixing alongside nitrogen greedy). Weeds can be spot targeted, rather than carpet bombed. Maybe even mechanically removed as opposed to chemically. Insect infestations likewise, identified, quarantined, and eradicated in a surgical manner.

The end result of these changes would be lower environmental impact, higher yields, and even higher productivity. There are some risks to consider in those changes. Probably highest is to avoid exploitation. When farming takes this future form, the risk of it being pushing out the existing manual labor is large. If that labor has no where else useful to go, it would be bad for society, even if the economics of farming have improved. Economics are not everything after all.

Minority rights

ryan.technorabble@gmail.com (Ryan Baker) — Fri, 24 Jul 2015 22:09:00 +0000

I've had a few conversations about the structure of the U.S. Senate where my conversation partner made the argument that the Senate protects minority rights. While this is to a limited extent accurate as a sentence, the context in which it was said always has led me to believe there is a bit of equivocation going on. That is to say, the phrase, minority rights has multiple meanings, and the one that if fit into that sentence allows it to remain true is not really the one my conversation partner meant.

The first thing to consider is the difference between rights of a specific minority or minorities, and rights of all minorities in general. The second meaning, which we can refer to as the right of minority, is not one we use all that often, but it's an interesting one. Rules that provide individual equality, but require greater than majority rule are example of this type of minority rights. Because all individuals are treated equally, anyone could be part of any specific minority. The theory behind such rights is that it forces greater deliberation, compromise and respect who might be disempowered otherwise.

The other meaning, that of a specific minority, first identifies or benefits the group, and then applies to the individuals. This is the type of minority right we talk of most commonly, though it's useful to note that as a general rule, we're talking about a certain class of such minority rights, disadvantaged minorities rights.

Without that additional qualifier of disadvantaged, this second meaning includes plenty of things that would not instinctively come to mind with the term of minority rights. A king or dictator is the smallest sort of minority, but if someone says they are for minority rights, you can be fairly certain they are not advocating for kings, queens, dictators, barons and such.

So getting back to the Senate, there is some truth if the right of minority is applied to some of the Senate's structure. The fillibuster is one such rule that allowed any minority larger than 33% to be a blocker.

But when I talk about the Senate, and what I see as a flaw in it's structure, I'm talking about the 2 Senators per state, and the unequal representation that each individual gets based upon which state they happen to live in.

That structure does nothing for the right of minority in general, instead it gives a specific minority advantage. This specific minority is not disadvantaged, it's a historical accident. A person in Wyoming has 65 times more representation in the Senate than a Californian.

Is there any logical reason for this advantage? Should California secede from the union and then reapply for statehood as 65 new states? If they did that, would there be a good explanation for why they now held 130 of 228 Senate seats but did not before? Would the voters in Six States of Orange County be now in need of the minority rights they lack today?

No, this form of minority right is completely different from the protection of disadvantaged minorities. The people of the Great State of San Mateo are not more valuable than the people of the lowly San Mateo County.

Hackers are like water

ryan.technorabble@gmail.com (Ryan Baker) — Thu, 16 Jul 2015 19:08:00 +0000

Security is always going to be tricky and a sort of arms race, knowing the individual techniques, measures and practices is an important part. That said, I think the main obstacle is motivation. Therefore I like the consideration of liability as part of this, but even that is too myopic to avoid most of the failures that are likely to occur.

As a professional in the software industry, I see the way that at many levels the motivation to treat security as a critical and uncompromising as it really is breaks down. Even if as a legal entity an organization has motivation by liability, how will this translate to the quarterly outlooks of CEOs and then their reports, each of which has the ability to obfuscate their security failures.. so long as they get lucky enough that nothing bad happens?

There is always a 20/20 hindsight applied to any exploited security vulnerability.. but what I think the public has not wrapped their consciousness around is that for every security vulnerability that has been exploited there are thousands or tens of thousands that no one bothered to exploit.

For that reason, after the fact liability will never reach deep enough into organizational structures to instill the comprehensive responsive necessary. Hackers are like water, leave the main hatch open and they'll flood right through... but close the main entry points and they'll find every little crack, wedging them open with pressure. The ship may sink a little slower, but sink it still will.

To really effect the necessary change, there needs to be penalties that occur before calamity. Penalties for failing security audits is one concept, that if given the proper weight could be effective. But who would assess these penalties? The logical actor is governments, but resistance to regulation of any kind makes that improbable.

Gold plating is 20/20

ryan.technorabble@gmail.com (Ryan Baker) — Fri, 08 May 2015 21:23:00 +0000

It annoys me the sloppy way the phrase gold plating is commonly used. For those non-developers out there, "gold plating" is a phrase that developers often use to describe features that weren't necessary, valuable or not worth their cost. It might be used outside development, certainly the same situation can occur in many professions, I'm just not sure if the same phrase is used.

The problem is that when people conceive of examples of gold plating, then do it retroactively and with 20/20 hindsight. Then they take that conception and apply it to planning. The outcomes are not favorable.

I feel like I need to provide an example to explain that. Say you have manager X, or analyst X. They look at some past projects, look at the feature sets and see that 20% of the features don't generate value equal to their costs. They then conclude that all those features are examples of gold plating at work.

The problem with that conclusion is that it's not useful. If they had looked at the feature plan, and how the different features were ranked during planning, and found that the bottom 20% turned out to not be used, that would be useful. You could cut the bottom 20%. But it doesn't work that way.. in many cases what doesn't get used is pretty hard to see in advance. How many great tools got used for unintended purposes?

So when you start with that first conclusion and then try to apply it to ongoing work, the data gets misused and important things are cut out. Maintainability and extensibility get especially hard hit.

Sure many extensibility features never do get used. But it's a mistake to conclude that means you can cut them all, or just the bottom 80%, because you really don't know what the bottom 80% are. This area is more guess work than other areas. In addition, the unexpected upside to the important extensibility features can be gigantic. Entire industries have been founded on extensibility features which seemed dull when first released. Six months later partners and/or community work made them the most valuable feature of all.

My Philosophy of Architecture

ryan.technorabble@gmail.com (Ryan Baker) — Wed, 21 Apr 2010 13:55:00 +0000

The first part of being a good architect is to observe. That means listening to others, using the existing products, inspecting some of the code, or getting involved in some. Unless there is a very specific technical problem you’re faced with day one, applying you’re technical skills day one is probably a mistake.

The second part is to identify needs. A key part of an architect’s position is to identify the needs that development teams didn’t know they had. Sometimes they do know these needs, but aren’t quite willing to admit it. It’s important to be careful in how you use that information. If you run out in to the office and shout out your findings, it’s unlikely you’ll meet the future steps with much cooperation from the development teams. I have to admit, I’ve had that lesson reinforced the hard way more than once.

The truth is that while you may be correct about those needs, the damage to trust is real, and justified since it’s likely upper management will see your declaration as a critique on the competence of the development teams. It’s not impossible that your discoveries are valid criticisms of the development teams, but it’s more likely there are historical reasons behind them. Deadlines, an unpredictable shift in technology, or an encumbrance that predates their time are some of the many possible root causes.

At the same time, it’s necessary to be providing solutions to the needs the teams already know. Sometimes those questions have uncomfortable answers. For example, they may be having problems with performance due to chatty communications. The answer they are hoping for is a super compression algorithm, but no compression algorithm can fix chatty communications. An architect is responsible for more than just solutions, an architect is responsible for mentoring developers and helping them understand why solution A cannot fix their problem and how to avoid ending up in the same trap in the future.

In the other direction, toward executives, an architect’s role involves setting expectations, and building support for the needs of development. Of course as well, there is much listening involved, because an architect must use information on product plans to determine what long term needs exist in development that have not yet been identified, and to evaluate the priority of those that have. Maybe there is a need to support a different platform, or a different device. Those needs would advocate more attention paid to how the user interface and model are separated.

Setting expectations not only covers the obvious, underestimation of effort and duration, but also the highlighting those areas where changes in software or hardware have opened new opportunities.

Since it’s common for development managers to have aggressive schedules, an architect often needs to be the voice advocating for a little more time here or there to get the fundamentals right. These efforts should pay off later, but since those benefits may be outside the project itself, organizational, or just longer term, it may be counter to the incentives given to other managers.

That conflict of priorities, and how to handle it, is often a greater challenge than the technical problems themselves. It would be appealing to see what would happen if an architecture department had an allocation of some kind such that it could internally compensate development teams for the extra efforts architectural initiatives may introduce to their product cycle. In my experience though, the main credit of an architect is trust. Cultivating trust among development teams and executives, making sure executives understand the benefits to overall development architecture brings. In addition, making sure executives understand the constraints of the development teams will win you trust among the development teams.

How the iPad (or a similar form factor device) can be successful

ryan.technorabble@gmail.com (Ryan Baker) — Sun, 14 Feb 2010 22:55:00 +0000

iPad rumors circled the Internet for more than a year before the eventual unveiling, and when finally unveiled, reactions were fairly mixed. Most importantly, they were mixed even among the hard core Apple crowd, showing some deep flaws in the marketability of the device.

I’m not in that crowd, but I’m similarly nonplused with what was announced. I own a Kindle and love it. I can’t see anyway that the iPad would be an appropriate replacement for it. It also isn’t a replacement for a laptop, and certainly not a cell phone. No, you’re right, it doesn’t absolutely need to be a replacement for anything, but as a stand alone device, even if you gave me one for free, I can’t see many situations in which I’d choose to put it in my bag.

All that said, I don’t think it’s entirely doomed. The problem I see is software more than hardware, though there are some areas for improvement there. What hardware like the iPad would do well at is as an accessory, not a standalone device. A touch sensitive screen of that size would make an excellent portable input device if the right software ecosystem existed around it for pairing it with TVs, PCs (this means Windows), music systems, etc. Essentially what I’m saying is it could be the ultimate remote control, though thinking of it as simply a $500-$830 remote control isn’t going to give you the whole picture.

I don’t think Apple has the right ethos to pull that off. Apple has a little too much of the “come to us and play by our rules” mentality to create an ecosystem in which a device like that would succeed. Apple’s partnerships tend to be either very closed and locked down (AT&T, Adobe for many years) or exploiting their fan base (App Store). Neither will work in this scenario because their fan base doesn’t make hardware.

Probably the biggest stumbling block would be the interfaces to PCs. It doesn’t seem likely Apple would ever consciously create a PC accessory. Sure they can do that same thing for Macs, but as an accessory it makes far more sense for desktops than for laptops. As an accessory to a desktop it would give you a convenient input device to remotely control the PC from and get notifications. That’s useful for AV, for communications, and for simple things.. like finding a recipe online, with a nice keyboard and monitor, then taking your pad into the kitchen.

Essentially what I’m talking about is a supersized SideShow device that not only hooks up with your PC, but with other hardware using either WiFi and/or Bluetooth. Still not sure I’d pay $500 for such a device, but it’s certainly something you could get me hooked on pretty easy, and once you’ve done that maybe you could convince me to consolidate devices and stop using a Kindle separately, making the $500 a little more palatable.

XML Schema 1.0 – Extensibility

ryan.technorabble@gmail.com (Ryan Baker) — Thu, 19 Nov 2009 04:20:00 +0000

One of the great flaws of the XML Schema specification, at least 1.0, is the great number of limitations placed upon the xs:any construct. The next version, 1.1, addresses or tries to address the majority of those flaws. But 1.1 isn’t final yet, and even when it is, the number of tools that need updates insures there will be continued use of 1.0 for some time still.

I’ve seen a few workarounds (a good list) for those flaws, and no surprise, all have limitations. I have a new one. It has limitations as well, but I for most situations, I think they are less important.

xs:any allows namespace to be declared as either #any, ##other or a list consisting of ##targetNamspace or any other namespace. #any is appealing except that you’ll nearly certain to run afoul of the determinism flaws of XML Schema 1.0. ##other is also appealing, but it really only solves your V1 to V2 issues, but leaves V3 not resolved. What you really need is a list of future namespaces.

So the solution is pretty simple, pre-declare your future namespaces. Here’s an example:

   1: <xs:schema

   2:     targetNamespace="http://norabble.com"

   3:     xmlns="http://norabble.com"

   4:     xmlns:xs="http://www.w3.org/2001/XMLSchema"

   5:     elementFormDefault="qualified"

   6:     attributeFormDefault="unqualified">

   7:   <xs:complexType name="Name">

   8:     <xs:sequence>

   9:       <xs:element name="FirstName" type="xs:string" minOccurs="0"/>

  10:       <xs:element name="LastName" type="xs:stirng" minOccurs="0"/>

  11:       <xs:any minOccurs="0" maxOccurs="unbounded"

  12:         namespace="http://norabble.com/v2 http://norabble.com/v3 http://norabble.com/v4 http://norabble.com/v5 http://norabble.com/v6 http://norabble.com/v7 http://norabble.com/v8 http://norabble.com/v9 http://norabble.com/v10"

  13:         processContents="skip" />

  14:     </xs:sequence>

  15:   </xs:complexType>

  16: </xs:schema>

The main difficulty with this solution is maintaining the “any”. For this purpose I have a “build” tool that among other things takes an XML schema written without the any and adds it. I’m working on an open source extensible project for that purpose called XsPub, but for various reasons it’s not very complete. Anyhow, at work I have something similar, just less extensible, and more specific to our needs (and finished ;p).

To actually make an extension you need to reference an element from the new namespace, and drop that namespace from your any.

For example:

   1: <xs:schema

   2:     targetNamespace="http://norabble.com"

   3:     xmlns="http://norabble.com"

   4:     xmlns:v2="http://norabble.com/v2"

   5:     xmlns:xs="http://www.w3.org/2001/XMLSchema"

   6:     elementFormDefault="qualified"

   7:     attributeFormDefault="unqualified">

   8:   <xs:import namespace="http://norabble.com/v2" schemaLocation="v2.xsd"/>

   9:   <xs:complexType name="Name">

  10:     <xs:sequence>

  11:       <xs:element name="FirstName" type="xs:string" minOccurs="0"/>

  12:       <xs:element name="LastName" type="xs:stirng" minOccurs="0"/>

  13:       <xs:element ref="v2:MiddleName" minOccurs="0"/>

  14:       <xs:any minOccurs="0" maxOccurs="unbounded"

  15:         namespace="http://norabble.com/v3 http://norabble.com/v4 http://norabble.com/v5 http://norabble.com/v6 http://norabble.com/v7 http://norabble.com/v8 http://norabble.com/v9 http://norabble.com/v10"

  16:         processContents="skip" />

  17:     </xs:sequence>

  18:   </xs:complexType>

  19: </xs:schema>

And the declaration of the element in the v2 namespace.

   1: <xs:schema

   2:     targetNamespace="http://norabble.com/v2"

   3:     xmlns="http://norabble.com/v2"

   4:     xmlns:xs="http://www.w3.org/2001/XMLSchema"

   5:     elementFormDefault="qualified"

   6:     attributeFormDefault="unqualified">

   7:   <xsd:element name="MiddleName" type="xs:string"/>

   8: </xs:schema>

The result is a set of schemas, v1 and v2 that both match the below xml document, but for which v2 understands the added content.

   1: <Name xmlns="http://norabble.com" xmlns:v2="http://norabble.com/v2">

   2:   <FirstName>John</FirstName>

   3:   <LastName>Doe<LastName>

   4:   <v2:MiddleName>Richard</v2:MiddleName>

   5: </Name>

Enjoy.

US EPA Big Polluters

ryan.technorabble@gmail.com (Ryan Baker) — Thu, 12 Nov 2009 04:08:00 +0000

Heard of the decision by the EPA to classify CO2 and other greenhouse gasses as pollutants, and regulate them? Whether you have or not, here’s are three other things you should know. First that first finding was supported in no small part by the 2,000 that gathered in Seattle outside the EPA hearing on that topic. Second, the EPA is proposing to move forward to the next step, actual regulation, starting with the “big polluters”, that is, new or modified sources of 25,000 tons or more of CO2 or equivalent emissions. Third, just like with the endangerment finding, the EPA is holding two public hearings, and one of them is next week here in Chicago.

This is an important event for climate change politics, and you like the 2,000 that gathered in Seattle can play a pivotal role. The Sierra Club is organizing supporters and we would love to see you there. There are two ways you can help.

First you can attend and testify, telling the EPA that you support the rulemaking. You don’t need to be a climate scientist, the EPA wants to hear from the public. In addition, Sierra Club will have a room at the hearing where you can stop by to learn more and get help preparing your testimony.

If you don’t testify, attending is still awesome. Pick up a sticker, listen to others, and show your support.

Last but not least, spread the word.

Sierra Club Flyer - http://tiny.cc/54Kb9

Software Engineering, Control, Measurement and Trust

ryan.technorabble@gmail.com (Ryan Baker) — Sun, 19 Jul 2009 16:12:00 +0000

There is much clamor over this article, “Software Engineering, an idea whose time has come and gone?”, by Tom Demarco. I love it. At work, I know a manager who has the tag line “You can’t control what you can’t measure” posted on his office door. It’s always given me the heebie-jeebies. Tom hits one of the main points right on the head, that it implies “that control is an important aspect, maybe the most important, of any software project”, But as Tom admits, “it isn’t.”

The other half is the how it plays together with the the "What isn't easily measurable, doesn't exist" rule. Tom sees this too, and describes it like this:

“Now apply “You can’t control what you can’t measure” to the teenager. Most things that really matter—honor, dignity, discipline, personality, grace under pressure, values, ethics, resourcefulness, loyalty, humor, kindness—aren’t measurable. You must steer your child as best you can without much metric feedback.”

I don’t fully agree with his prescription, to require the product team to be ready to ship in any given week of development. Like the original guidance, there is a kernel of truth here, but an overreaching of application. There are many good reasons to pursue a “ready to ship” strategy, but you need to be flexible. You need to accept that there are some tasks that will break that goal. You cannot replace important subsystems without causing at least a bump, and sometimes you need to do that.

If you have the goal in place, but are flexible, then you can create a branch, do most of the work there, and once it reaches a certain level of maturity (no longer experimental), integrate. Integration will cause some pain, on both sides, and you have to balance between disruption to the mainline team, and your ready to ship goal, and the probability that if you insist on zero mainline pain that the branch may never merge.

But anyhow, though it sounds like a prescription, Tom says it’s an example, and as an example it’s perfectly valid.

Like raising a teenager, when you have important things, that aren’t easy to measure, what you need is trust. You need to be able to trust that your team understands your motivations, your goals. They need to be able to trust that you will treat them fairly if they help achieve those goals. A ready to ship strategy is just an example of “don’t do anything too crazy”. It can help build trust because management can visibly see progress, and because hopefully when management sees that they say “thank you”.

S+S Synchronization

ryan.technorabble@gmail.com (Ryan Baker) — Mon, 04 May 2009 02:22:00 +0000

Software and Services (S+S) solutions have a number of attractions, but one common attraction is the ability to work offline. Some S+S solutions have clients that require persistent internet connections, or are read-only in offline mode. However, most developers that choose S+S as their architectural blueprint do so, at least in part, with a desire to provide users strong offline capabilities.

The difficulty with offline editing is the possibility of conflicts and the need to provide conflict resolution. Some applications ignore this difficulty because they are single user, and are willing to leave that user responsible for any data loss that results from accessing services directly, or from multiple clients without synchronizing work done offline on others. Other applications are entirely read-only, eliminating the difficulty in a different way.

Many applications don’t fit inside those constraints, and when they do inevitably synchronization is brought out as a topic. Discussions of synchronization often start out with a bit of wishful thinking. That is, someone, or many participants believe there is a synchronization black box they can throw data at and all will be automatically resolved. To my knowledge, that doesn’t exist. In fact, I’ll go as far as to say, that I believe it cannot exist. Unless you design your data to fit a strict structure that communicates your business rules, and those rules never require escalation to human judgment, such a system cannot correctly resolve all conflicts.

I’ve come to the conclusion that synchronization cannot be a black box. Synchronization requires more than read/write to be exposed to the developer. For S+S solutions, the synchronization architectures I prefer are those that expose more data to the client. There are a number of ways to implement that, but I’ll explain one of the simplest.

First, begin with a centralized master, your service, that is the authoritative source for data. This service needs to support two things for every synchronizable item. First, it needs an identifier that is guaranteed to be unique and unchanging over the lifetime of the item. Second it needs a versioning identifier. It could be a sequentially incremented number or timestamp, but I prefer another unique id.

Next, in your service, implement (or re-use) a read-only caching system. If this sounds pretty vanilla so far, that’s because it is. These first two steps can be achieved through the use of HTTP, URI’s and ETags.

Where many implementations go wrong is the next step, where they attempt to convert their cache into a read-write store. The most obvious problem with that choice is it breaks everything you’ve built so far, since a cache is one way. The other problem is you’ve implemented a store that has two sources of data, and have no mechanism to rationalize which one wins. You could create a mechanism, but there isn’t any perfect mechanism.

Instead of forcing the cache to transform into something more complex, leave it alone and create a separate store for modifications. The client is then responsible for attempting to keep that modified store as empty as possible by submitting the modifications to your services. Every submission is tagged with the versioning identifier of the item that was present in the cache when modification began. If this sounds like the HTTP “If-Match”, then you have the idea. Services should not accept modifications that are unaware of the content of the latest version they have accepted.

Now, if a submission is rejected, you’ve detected a conflict. Your options are many at this point. No option is perfect, and the choice is going to depend on many things, not the least of which are your user’s requirements. But no option has been eliminated yet. Without any additional implementation you have a first-in-wins strategy, which happens to be the safest bet without more complex insight into the data’s structure, or user intervention.

If you want a last-in-wins strategy, re-cache, update the versioning identifier and resubmit. Since this would potentially destroy a previous set of updates, it would be bad practice to do so without some kind of user prompt or notification.. but you and you’re users are in control, not the API.

If merging is necessary, the essential complexity of the merge itself remains, but not much else. You have a copy of the original version, you can retrieve a copy of the current version, and you have a copy of the modifications. Two-way merge, Three-way merge, automated merge, manual merge.. whatever is necessary is possible and not any more difficult than absolutely necessary.

How to load test: Step 1 – Create a realistic load

ryan.technorabble@gmail.com (Ryan Baker) — Thu, 23 Apr 2009 03:39:00 +0000

Load testing isn’t the easiest job invented. Depending on your business model, load testing can vary from important to absolutely critical. So despite the pains, every project at least makes a token gesture toward load testing. Unfortunately, either knowingly, or unknowingly, it’s often not much more than that, a token gesture.

The primary failure in the average load test is not creating a realistic load. There are plenty of excuses for this. There aren’t any servers comparable to the production servers. It’s too hard to produce test data that simulates true data. Or worse, you don’t even know what production load will look like. Those aren’t minor obstacles, calling them excuses isn’t meant to trivialize them, it’s more a reflection of the true importance of load testing, and knowing that when you do it, you do it right.

The less and less realistic the load you generate, the more your test becomes performance analysis. Performance analysis is great, but load testing and performance analysis are different animals. You are doing yourself a disservice if you use a fishing rod to catch a great white, or a harpoon for goldfish. If half your team is trying to do performance analysis and half is trying to load test then you will waste time you wouldn’t with a clear mission.

There are other things that distinguish performance analysis from load testing, but the number one is the type of load you generate. A performance analysis load may sometimes resemble a true load, but it usually should not. A performance analysis load should be structured to make it easy to pinpoint performance issues. A true load makes this more difficult by being too complex or too chaotic. So unless you’re tuning something that only performs badly in complex or chaotic scenarios simplify and isolate for performance analysis.

Load testing, by definition, needs a true load, or as close to it as you can approximate. Load testing is a validation. Load testing is developing reasons to be confident that under expected conditions, your system won’t fall over. Load testing is about giving assurances that it’s not a bad idea to depend upon the reliability of your system.

So all that said, how do you create a realistic load? If your software is like most, there is one, or probably many points where in the real world, a user takes some action. Since in the real world you have lots of users, you’d ideally want to automate all of those steps. Sometimes that’s not that difficult, and if it’s not, that’s the path to take. There are tools that can simulate clicking “submit” on a web form. Many of those same tools can simulate filling it with some data, or even using an AJAX control. But all of this has limits. If you’re within those limits, take the easy path. If you’re not, you’re either going to have to take the next step, or settle for a sub-par load test.

Moving work from the server to the client is sometimes an effective strategy to improve scalability, among other possible benefits, but it’s definitely going to complicate your ability to automate your steps with cookie cutter solutions. There are two paths you can take in that situation. One choice is to start from scratch and use your knowledge of your software to generate data from a template, substituting in values coming from preceding steps, and maybe some randomness. The second is to reuse code from your application and wire those pieces together.

Which choice you make is going to depend on your code. Using your application code has many things going for it, but you have to surmount several common challenges. First, if you have thousands of users (or millions), you’ll need your application code to simulate more than one. No matter how minimal your application, it’s very unlikely you can run hundreds or thousands of copies of it on a single box at a time.

Depending on how well you meet the first challenge, you may also need to make sure your application code can run in parallel on the same hardware. Usually this means multiple processes. Why wouldn’t you need multiple processes? If you can make one instance of your application code simulate a large number of users, and thus consume the overall load generating capacity of the hardware, then the second challenge can be skipped.

Either way, with a large number of users, you may find that a single machine isn’t going to have the ability to generate sufficient load. If one, two or three machines are necessary you may feel happy with manually starting instances. At the least do yourself the favor of using a tool like PsExec to let you do that from a batch file or something.

Summary

Whatever path you’ve taken, you are now generating a load. The challenges aren’t over though. Now need to validate you’ve met your load and that it hasn’t caused anything to topple over. That means monitoring and analyzing stats and logs. And if you do find a problem, you’ll need to switch hats back into performance analysis to hone in on the exact cause and find a solution. Since those aren’t topics to be taken lightly, I’m reserve them for a future date.

How higher gas taxes benefit you

ryan.technorabble@gmail.com (Ryan Baker) — Sat, 04 Apr 2009 19:33:00 +0000

The United States ought to raise the gas tax, and we ought to do it soon. There are so many good reasons its going to be hard to explain them all. To start with, we have 1 or 2 years until, crude oil prices start to climb again. We ought to be prepared for that when it happens and the best way to do that now is to pretend as if those prices are here today, when we can collect the money and send it to the Federal Treasury, rather than pay the price later to a Saudi sheik.

The second reason is both current and future prices. The more effectively we control demand, by making choices that won’t cost us in the future, the better we protect ourselves from high prices in the future too. In other words, we can delay the rebound in crude oil prices by an extra year or two, maybe even more, by dampening demand through a tax. Every Prius substituted for a SUV today lowers the pre-tax price of gasoline by some fraction in 2010, 2011, 2012, etc. It’s also non-linear. If demand stays below today’s production, prices will stay at today’s prices, or lower. If demand exceeds production, then all hell breaks lose again.

Those two reasons are symbiotic. I’ll illustrate with some hypotheticals. In the status quo scenario, no additional tax, gas might stay around $2.00/gallon for the next 2 years. But in the meantime, the economy may (hopefully) recover, and about a year from now with a good economy and low gas prices, I wouldn’t be surprised to see SUVs flying off the shelves all over again. Keep that up for a year, and demand could grow back from 19.5 mbd to 22mbd. If that happens, then certainly crude will skyrocket again, and we’ll see $4.00+ gas in later 2011.

On the other hand, if an additional 50-75 cent gas tax was added, I think we would hear a different message, and demand might even decline a little further, say 18.5 mbd. Here is an example of what the implications might be in terms of the amount of dollars sent tot he middle east, and the taxes collected. In the short term there would be some consumer costs, but many of these costs might be offset by tax reductions in other areas.

In the long term, consumer costs actually end up lower because a) they were prepared to use less gas, and b) demand was lower resulting in lower gas prices.

Most importantly, a 10% difference in demand can translate into a 50% difference in the amount of money sent to the middle east, of which we know a certain percent falls into the hands of terrorists. With any luck, the people of Saudi Arabia, Iran, or at least those with the checkbooks, will see terrorism as the first “discretionary” spending item and strangle those funds much more than 50%.

New Version of deSleeper, and manual.

ryan.technorabble@gmail.com (Ryan Baker) — Sat, 04 Apr 2009 03:02:00 +0000

I’ve posted a new version of deSleeper, v2.0, to codeplex. This version adds some functions to help network administrators setup a couple hundred machines to work with deSleeper with fairly minimal effort. And to help the non-admin user (and probably the admin too…), I’ve finally put together a deSleeper manual. You’ll always be able to find it on codeplex, but here’s a little RSS copy too.

If you're setting up deSleeper in a network, you may want to read the deSleeper Setup & Architecture Guide as well. This guide will cover the features of deSleeper from simplest to most complex.

Wake Up!

If you're using deSleeper, the first screen you'll see is the Wake Up Page. If you're not setting up servers this might be the only tab you ever use.

To start off you need to supply information about the computer you're trying to wake up (the "target"), and how to get your request from your PC to the target.

Initially you have no targets configured, so click on the New Target button. You can type whatever you like in the Description field, it's for you alone. If you're using deSleeper, it's probably because you want to use the proxy functions. What's a proxy? It's a service that helps get a message from one place to another. If you setup the proxy, then I hope you know the host name, and if you didn't hopefully your friendly network guy can fill in the blanks. Either way, type the name into the proxy field.

You've got two choices for how to identify your target, MAC Address, and host name. If you've never heard of a MAC Address, don't fret, you only need one, and host will do fine. For more advanced users, MAC Address is a little more surefire (though a lot harder to memorize!).

Once that is sorted out, click on Wake Up Now, and you'll either see a nice little success message, or an ugly yellow error. Let's hope for the first.

Network Card Configuration

The second most likely place for a casual user to wander is the Network Card Configuration Page. There's not a lot here, but it consolidates three important items you'd have to hunt all over your PC for otherwise.

The first is you can find out your MAC Address here. Of course, it's the MAC Address of the PC you've just run deSleeper on, not the one you're trying to wake up, but there isn't anything preventing you from installing deSleeper to the PC you want to wake up. Actually everything on this page is best down on the PC you’re trying to wake up.

The second item here is the ability to enable you’re network card to listen for the “magic packets”. Such a nice name. Magic packets are the magic that takes a computer sipping 1 watt and turns it back on as if you walked over and pushed the power button.

Once deSleeper has given you a reliable way to wake up your PC remotely, you’ll want to configure the PC to use its built-in power saving features. You can configure these in more detail through your computer’s power options control panel, but for convenience the main setting, the sleep timeout can be updated here.

Service Installation

If no network admin has setup a proxy for you, and “Wake up a machine on your local network” isn’t working, it’s not hard to setup your own. All you need is a PC which will remain on. Most offices, unfortunately, have hundreds of these, so take advantage of one. You install a service through the Service Installation Page

The easiest thing to do is to install deSleeper on the machine you want to use as a proxy, come to this page and click Install. There is no need to change any of the default settings if you don’t understand them.

It will however be helpful to type the names of the machines you want to wake up into the Precache Hosts field, before clicking Install. This option makes your first wake up easier and reliable. It’s optional, but highly recommended.

The other option is to do a remote install. This function is really for more advanced users as it requires access rights the average network user won’t have, and some of the error messages that come back if you’re missing one of those rights are, somewhat of necessity, not all that user friendly.

One common gotcha of remote installs is that .NET 3.5 SP1 needs to be installed before you hit the Install button. To try and prevent confusion, by default, deSleeper checks to see if .NET (and the right version) is installed. But to do so requires a service, the Remote Registry Service, be enabled, which many users disable for security reasons. To skirt this issue, click suppress check for .NET. If one of the installs fails you may have to manually check if .NET is installed.

There is yet one more function available from this page. The Prepare Hosts button will take each PC in the Precache Hosts field and attempt to remotely enable the Wake-On-Lan setting on that PCs network card. Like remove service installs, this requires administrator, or close to it, access rights. For the techies, I’ll mention that this feature, and the remote install feature, is made possible by RCtrlX, a utility from Leon Sodhi. Thank you Leon!

Summary

So that’s about it, if you get an error message when doing anything, you’ve got a couple options. The first is to head over to the deSleeper discussion list. The client writes log entries to a file deSleeperClient.log, which is in the same folder as the executable, C:\Program Files\deSleeper (at least for now.. by all standards it should be in AppData but for now it’s in the much easier location).

The service writes most errors to the Application or System Event Logs, which you can get to through Event Viewer. As with all networking related tools, it helps to know a little about what your network is composed of, but in the interest of not overcomplicating this little guide, I’ll leave those as topics for another day.

deSleeper Version 1.11

ryan.technorabble@gmail.com (Ryan Baker) — Thu, 26 Mar 2009 14:41:00 +0000

I’ve released a new version of deSleeper. This update provides an alternative way to “precache” hostnames in a kind of offline ARP table. Also fixes some errors that occurred when additional types of network cards (such as those VMWare installs) were present.

deSleeper Architecture

ryan.technorabble@gmail.com (Ryan Baker) — Sun, 22 Mar 2009 20:30:00 +0000

I run an open-source project, deSleeper, on Codeplex. The purpose of this utility is quite simple. Allow users to remotely wake up their machines from low-power states. If users use these features they’ll find it more practical to have their PC’s off or in sleep mode more often, thus saving energy.

Every network card has the basics to make this work, but there are plenty of obstacles that can get in the way. The purpose of deSleeper is to give ways around those obstacles, and hopefully simplify the process as well. I think I’ve succeeded in the first goal, though the second is still a work in progress. It’s simpler than without deSleeper, but it isn’t average user simple.

While I work on that, anyone who uses deSleeper may find it helps to understand the architecture when you're unsure how to setup your system. I’ve endeavored to help you do this by writing an architecture and setup guide.

First, you should understand the components that are used for the entire interaction.

The three main components are the client, the proxy and the target.

Target - The machine that goes to sleep automatically or manually and needs to be reactivated remotely.
Client - The machine you're using when you want to wake up the client.
Proxy - The machine which listens for requests from clients and uses it's superior network access to get a magic packet to the network card of the target.

Understanding these components helps understand the steps necessary to set them up.

These steps are:

Configure the target's network interface. It is not always necessary, but many network cards do not have wake-on-LAN enabled by default. You don't need deSleeper to do this, but help you avoid hunting around in Device Manager deSleeper provides the "Network Card Configuration" tab. If you know how to do this without deSleeper's help you don't need to install deSleeper on the target.
Install Proxy Service - Clients usually have obstacles between them and the target. The proxy service needs to be installed on a machine physically located on a network that avoids these obstacles. The safest spot is connected to the same network switch, but depending on your network setup farther away may work as well. There are plenty of variables here so when in doubt closer is better. The "Service Installation" tab is only available if you install the full version. This tab helps configure the proxy service which will run in the background and boot with proxy machine.
Install Client - The easiest step, install your client. You can use the full version or the client only version.

Once everything is setup, all that is left to do is send a wake up request.

The requests use web-services calls to contact the proxy with the target information. Where this request is sent is the "destination". deSleeper also supports a "local" destination that does not use a proxy, but requires the client and target not to have obstacles in between each other.
Either the proxy, or if "local" the client, then constructs a "magic packet". Essentially a magic packet is a set of bytes in a simple pattern that the network card of the sleeping target can recognize it without the assistance of the CPU. When the network card recognizes a magic packet stamped with it's unique name (known as the MAC address), it sends messages to other components of the machine that turn on the CPU, memory, hard disk, etc, or take them out of super-low power states into operational states.
What can go wrong?

If the network card isn't watching for the magic packet it won't wake up the machine.
Magic packets are broadcast. Because the machine is off, it's not really possible to direct the request at the target. Networks limit the scope of broadcasts for many reasons. If the machine that broadcasts the magic packet is in a different scope from the target, the broadcast will never reach it.
When using the "Host Name" wake up method, it needs to be possible to resolve the Host Name into a MAC address, because the MAC address is a critical part of the magic packet. On most networks it's not possible to do this while a machine is off. For this reason, the proxies maintain a "cache" of host name and MAC address pairs. But to initialize this cache it's necessary to send a wake up request once while the machine is on. Somewhat counter-intuitive to send a wake up request while online, which is why I'm looking into some other solutions, but it works well after the single request. Cache's on a proxy survive shutdowns and restarts, but they may not survive a reinstall of the deSleeper service.

Idempotent Sequences, Sets and Interactions

ryan.technorabble@gmail.com (Ryan Baker) — Sat, 21 Mar 2009 03:29:00 +0000

Idempotency is a funny sounding word with a simple meaning, but a complex reality. Perhaps it’s even unfair to say it has a simple meaning because I’ve seen many attempts to define it that turn out rather convoluted. In the simple terms, I would define idempotency as the property of being able to perform the same action twice or more times in sequence, and end up with the same result as if it was performed once.

Those terms leave a fair bit of wiggle room when you really get down to the details. For example, those terms say nothing about additional actions occurring in between the first and last occurrence of the idempotent action. If there is one and only one action that can modify a resource than it’s not necessary to consider those details, but quite often that is not the case. Even operations like an HTTP PUT are only idempotent when the input is the same. Every different input for PUT is non-idempotent, with respect to every other input, unless of course If-Match is used and then some inputs are idempotent to other inputs but not to all.

As I’ve found in relation asynchronicity, a simple word, used without context, can cause more confusion than clarity. The transmission of a message and the receipt of it’s response may be asynchronous from a user’s perspective, but still remain synchronous from a HTTP protocol perspective. That is, from the user’s perspective clicking a link in the browser is asynchronous, because while the requests are sent, received, processed and rendered, only any modern computer the user can click on another tab, open another program, etc. But from the HTTP protocol perspective, even if the HTTP library provides a method like BeginGet, EndGet, some infrastructure is required to construct the request, transmit that request, and do nothing else until the response arrives (Even this is blurring the truth a bit since there is the timeout…).

So, back to idempotency, I rarely see the context of idempotency discussed or defined in a more clarified structure. I’ve occasionally seen references to idempotent sequences, but very rarely, not even enough to feel confident that my definition is the same as everyone else’s. The HTTP RFC gives this description:

A sequence is idempotent if a single execution of the entire sequence always yields a result that is not changed by a reexecution of all, or part, of that sequence.

I wouldn’t be at all surprised to find people who would believe an idempotent sequence was a sequence, that if performed twice or more in a row was idempotent, but the description above goes farther than that. In that description, the order of first execution of each action must remain constant, but reexecution can occur anytime after this first condition is met.

I can think of another, stricter set of actions, where the set of actions produces the same result regardless of order entirely, the only requirement to achieve the same result is that every action in a set is executed at least once. For the lack of knowing anything better to call such a set of action, I’d call them an idempotent set.

I think it’s not uncommon for architects and developers to overreach at times and assume something that is a collection of independently idempotent actions, is an idempotent set. You need an idempotent set in order to accommodate fully out of order execution, with a deterministic result. An idempotent sequence works only if you’re willing to accept a slightly non-deterministic result.

Another common circumstance that arises, is a set of actions, that will result in the same outcome as long as the first execution of a “final” action follows the initial execution of all other actions. This circumstance, which I’m struggling to find a good term for, is quite common.

I would love to hear from others on what definitions, or other common interaction patterns you’ve had experience with that relate to idempotency.

Red Light Cameras

ryan.technorabble@gmail.com (Ryan Baker) — Sat, 28 Feb 2009 21:46:00 +0000

Chicago has been installing red light cameras. I thought one caught me a few weeks ago, but never got a ticket, so the flash must have been for a car going the opposite direction. The experience got me wondering about certain aspects of the systems.

If you search, you’ll find opinions that they are effective at reducing accidents, and others that they are not. The only definitive RLC study I found, conducted by FHWA, has interesting conclusions. Bottom line is red light cameras reduce both injuries and costs. The FHWA study is much better than others, but it’s important to note it’s limitations.

The FHWA study discusses spillover effect, that is, the effect where RLCs alter the behavior of drivers at intersections without RLCs. When a city places RLC’s at a few intersections, some drivers pay attention to whether a intersection has a camera, but others become more careful at all intersections.

What the study can’t measure, because there is no data for it, is what the effect would be if all drivers acted like the second group, that is, they drove more carefully at all intersections. This condition would occur if all intersections had cameras or a high enough percentage as that drivers assumed they were present without looking for them.

This limitation is important because all the benefits of this homogenous state, compared to the current mixed state, favor RLCs. First, in the mixed state, drivers intentions and expectations vary more than in the homogenous state. If a driver who knows a RLC is not present at an intersection is following one assumes all intersections are equipped, the following driver may assume the leading driver is less likely to stop than he is, increasing the risk of a rear-end collision. If all drivers have similar goals, the risk is reduced.

Second, if drivers look for RLCs as they approach an intersection, this is a distraction, and increases the risk of any type of accident, especially rear-end collisions. If they assume the camera is present, plan to stop, and focus their attention on traffic and signals, the risks are lower.

The point is the proven, but modest benefits the FHWA study finds are underestimating the full value, and while we may each dislike the chance we’ll receive a ticket, ultimately they do save lives, injuries and costs.

Google, Brand and Beta

ryan.technorabble@gmail.com (Ryan Baker) — Sun, 15 Feb 2009 20:55:00 +0000

Reading Dare Obasanjo’s thoughts on how layoffs and project trimming at Google affect its culture led me to thinking about why the fatality rate for side projects at Google has risen so high. It’s not just the economy, it’s more than that. I think despite being the major innovator in web based advertising, Google may have failed to understand the meaning of brand internally.

What Google has been loathe to admit to itself is that a not insignificant part of its success in many areas is something other than the quality of their products. Not that they don’t have quality, or that quality wasn’t important, but many of their products have succeeded by leveraging the brand built from the success and popularity Google web search and the following press obsession with the periods of rocketing stock prices. This brand was critical for products like Gmail which asked users to change the way they work. Gmail asked users to give up something in exchange for something else. Products like that are a much harder sell then products that provide incremental improvements, and the ability to convince users to temporarily ignore their losses until they understand their gains is critical.

That ability is called trust. Google however has damaged their earned trust in somewhat unexpected ways. Maintaining trust isn’t as simple as not breaking your promises, because people aren’t fully rational about trust. Causing confusion is as reliable a mechanism to lose trust as lying, and Google has done a good job of confusing users with their extremely long list of beta products. Sure, they are called beta’s and the implicit statement there is that it’s not complete, but since some of their beta products have had quality far above others, the meaning of beta changed.

What Google would benefit from here is to do a much better job of internally vetting the state of quality of their products and projects and communicating that to their users and potential users. Currently I have a feeling that Google’s main metric of quality is the number of daily users. That is a poor metric that is self-defeating in the brand arena. Those products that have succeeded, and are already successful don’t need a stamp of approval, but those that do are left among the rather large and growing bucket of products that either haven’t yet made it, or never will.

Photo fun

ryan.technorabble@gmail.com (Ryan Baker) — Wed, 28 Jan 2009 06:53:00 +0000

One of my many projects over the last few months has been cataloging and uploading my Grandfather’s very large digital photo collection. It took a bit of time to decide on the right tools for this job, and in all honestly I’ll probably switch again sometime in the future but so far I found the combination of Windows Live Photo Gallery and Flickr to be the best combination.

Windows Live Photo Gallery beat out it’s competitors for me because of did a better job of managing tags than all the others. It supports two types of tags, People tags and descriptive tags. People tags are cool because you can highlight individuals in a photo, but I haven’t yet figured out how this is stored. Descriptive tags are you’re basic tag but are stored in a form Vista recognizes directly making them very portable and useful for searching even without Windows Live Photo Gallery. Inside Windows Live Photo Gallery the interface for using the tags is very good too. I won’t say anymore on that topic other than suggest you try it.

You might be tempted to think the use of Windows Live Photo Gallery would make it easier to upload to the Windows Live Photos service, but there is an excellent uploader for Flickr built in. It’s way better than anything Flickr offers on their own, and in some ways better than the built in upload to Windows Live Photos as well. Once again, a key factor for me was the support for tags. The uploader in Windows Live Photo Gallery automatically transferred all of the descriptive tags. The standalone flickr uploader tool requires you type all of this in again.. ugh.. no thanks.

Flickr got my support for a couple reasons. For one, I had a lot of photos, 50GB or so, that I wanted to upload, and for a number of competitors that would have cost quite a bit. Actually, until AT&T discontinued their Yahoo services it was free for me. Now it’s $24.95/year. Picasa, is kind of expensive past the initial 1GB. Windows Live Photos was kind of attractive with 25GB of free space, but the online experience isn’t anywhere near the depth of Flickr. For example, while tags are transferred, they aren’t all that useful due to lack of good search/exploration interfaces. I think my feelings on that would change a lot of there was a online/offline sync between Gallery and Spaces like Picasa uses, but today it’s just a standard upload/download like Flickr.

So… now that I have all these photos and a inherent sentimentality toward them I’ll probably be posting links to some of the best in the ol’ blog from time to time. Hope you enjoy them.

Remote Desktop 7 on Windows Vista and XP

ryan.technorabble@gmail.com (Ryan Baker) — Mon, 26 Jan 2009 03:57:00 +0000

While Vista/Windows 2008 Server were in beta there was a trick to use RDP 6 on Windows XP. Now that Windows 7 is coming, and has a new set of RDP enhancements, including true multi-monitor support. So, I decided to try the same trick with the new files from Windows 7. To recap:

Create a folder for you RDP 7.0 (version number will be 6.1.7000) files (don’t place them in System32)
Copy the files mstsc.exe and mstscax.dll from a Windows 7 installs System32 folder to the new folder.
Create a subfolder, en-US.
Copy the files mstsc.exe.mui and mstscax.dll.mui from the Windows 7 installs System32\en-US folder to the subfolder.

Now, my testing has had some success under Vista, but not so much under XP. I did a bit of an odd thing for Vista because I have a 64bit install of Vista and had a 32bit install of Windows 7. So.. when I copied the files they didn’t initially work until I ran them inside a 32bit version of dependency walker… but I’m pretty sure it will work without that hoop when I copy over the 64bit files, or vice versa if you have two 32bit installs.

The XP problem is a bit trickier. Under XP (32bit files/32bit install) I receive the error “The prerelease version of remote desktop connection has expired…”, which happens to be the same message many users saw during early XP SP3 testing. For this reason I have a hunch that the files will work on XP SP2, but not SP3, but don’t quote me on that till I get a chance to try. Other than that I haven’t thought up anyway to make the files work on XP other than to wait for Microsoft to release an official patch.

Windows 7, Remote Desktop and Dual\Multi Monitors

ryan.technorabble@gmail.com (Ryan Baker) — Sun, 25 Jan 2009 19:23:00 +0000

A long time ago I wrote about a partial solution to using multiple monitors with Windows XP and Vista. There were a few limitations at the time, but now Microsoft is promising to solve even those. With Windows 7 (and lets cross our fingers and hope the Windows 7 Remote Desktop client becomes available for Windows Vista and XP), you can now use two or more monitors, even with different sizes with remote desktop.

Some early details, about multi-monitor remote desktop on Windows 7, are available from the Intel networking blog. One thing I should point out is that this is much different than /span. With /span you didn’t get distinct monitors, so maximize wouldn’t work as expected and you all your monitors had to have a common rectangle. That is, if all your monitors had a consistent height, and were horizontally stacked, then you could use them. With the Windows 7 change they are actually treated as distinct monitors allowing for distinct sizes, which is rather handy if you have a laptop with an external monitor and the sizes don’t match.

This is all nifty and cool, but it’s possible it won’t matter much if the entire remote desktop concept trends more toward the remote application concept. More on that soon.

Kindle Case (Solution?)

ryan.technorabble@gmail.com (Ryan Baker) — Sun, 25 Jan 2009 18:15:00 +0000

I’ve had my Kindle for about a year now, and continue to run into more and more people with one. The one gripe I hear consistently is the case. Oddly it’s never bothered me, I’ve found the case, while unconventional, to have worked extremely well at it’s job.

Maybe I’ve been lucky to get a case that was just better fitted, but I haven’t had the “drop out” issue many complain about. Yes, the little tab and the back of the Kindle seem to barely hold on, but they always do hold on, except if the battery cover on the back of the Kindle starts to loosen up. Maybe that’s the trick, or as I said, maybe my case is more perfectly fit than the others.

When the battery cover is properly tight the curved edge will be totally flush with the curved edge of the kindle. It’s possible that it might feel like it’s tight before it is, but it will be more obvious if it’s tight. My apologies if this is all obvious and already tried, but considering my good luck so far, and the off chance that it might work, I thought it worth a try.

Low Power PC Tips

ryan.technorabble@gmail.com (Ryan Baker) — Thu, 15 Jan 2009 02:20:00 +0000

In most cases, PC’s help save power. Less shipping due to email is one good example. Still, they do plug into the wall and if not properly configured can use a fair bit more electricity than necessary. What’s unfortunate is that most PC’s aren’t configured properly because they don’t come from the manufacturer that way.

I’m going to give you some simple tips to save power. I’ll start with those tips that won’t produce any noticeable change in the way your computer operates (unless you happen to watch your electricity meter), and then some that save more but have minor inconveniences.

Minimal Power Management

The first tip is to let your computer take advantage of the power saving features of your CPU. Modern CPUs can use dramatically less power when idling or under light load, by turning off some cores and slowing down others. Since they only do this when they don’t have work to do, the effect is unnoticeable. Unfortunately, most Windows XP computers come configured with these features turned off. In Windows XP you can enable these features through the power options dialog accessible through your control panel.

Windows XP

It’s not too obvious here, but choosing minimal power management does more than just change the values of the “Turn off monitor”, “Turn off hard disks” and “System standby”. It also changes many subtle unseen values. So the tip here is, set your power scheme in Windows XP to “Minimal Power Management” if it’s currently set to “Home/Office Desk” or “Always On” or “Normal”. The “Portable/Laptop” and “Max Battery” schemes are roughly the basically the same as “Minimal Power Management”, except with different defaults for the visible settings.

VISTA

In Vista, processor power management is something that is on by default. Also you can see the actual settings, though it’s a bit more involved. Vista has power plans instead of schemes and they vary a little bit. In general you’re okay if you don’t choose “High Performance”. I know it sounds like something you want, who doesn’t want performance, but really the difference is negligible in terms of performance and high in terms of power usage.

If you want simple, choose recommended to get the equivalent of minimal power management.

On the other hand, if you want to really know what your PC is doing, further down I’ll explain Advanced Power Settings.

Turn off monitor

Modern LCD monitors and laptop screens use much less power than the older CRT monitors did. Still, they are one of the primary power draws from using a PC. Also, unlike CRTs, an LCD turns on and displays an optimal image in less than a second. So setup your computer to automatically turn the monitor off in case you get up and walk away.

Don’t worry about your monitor turning off while watching a video. Media Player and most other video software keeps the monitor on automatically regardless of this setting.

Choose whatever timeout feels comfortable, but lower is better. I set mine to 10 minutes at home and 5 at work (for security mostly).

Another tip, don’t use a screen saver. For one, they’re no longer necessary given the design of monitors today. Second, screen savers have an odd nack for preventing your monitor from being turned off, although they are not supposed to do so.

Windows XP

Select your time after selecting the appropriate power scheme. If you set the scheme second the turn off monitor setting will change again.

Vista

Click on Change plan settings after selecting a plan. Instead of “Turn off Monitor” use “Turn off the display”.

Turn off hard disks

Hard disks turn on and off very quickly too, and depending upon how you use them, they can last quite a bit longer if they get some down time. It’s generally not good to turn a hard drive on and off rapidly, kind of like a lightbulb, but a few times a day will do more good than harm.

I’d recommend setting the hard drive off to 10 minutes.

Windows XP

Once again, select the appropriate time after selecting a scheme.

Vista

In Vista, turn off hard disks is more complex. Click on “Change advanced power settings” once into the Change Plan settings.

This is good and bad. On the bad, this dialog is much more complex. But on the upside it does allow you do to a lot more than XP did. Expand the Hard disk node, then “Turn off hard disk after”, and finally select the appropriate timeout if not already set. You might notice something inside this screen. A bit further down is “Processor power management”.

This is the equivalent to “Minimal Power Management”. 5% and 100% are very good values and should be the default values in your Recommended plan.

Sleep/Hibernate

The last step in saving power is to enable sleep and/or hibernate. These features turn your whole computer off, not just little pieces, and allow you to bring it back to life quickly. Sleep is almost always the faster of the two and the difference in power consumption between sleep and hibernate isn’t huge. I generally prefer to use hibernate explicitly (as a replacement for explicitly shutting the machine down) and sleep as a “walked away” kind of thing. If you’re faint of heart, start with standby unless you have a laptop.

I’d suggest setting this to at least one notch above your monitor off value. It’s nice to have a warning before the PC goes to sleep. If your reading something and you’re monitor flicks off, move the mouse and in less than a second your back to normal. If however it goes to sleep it could be a a little wait because you’ll not only have to wait for the PC to come out of sleep, which is pretty speedy, but you have to wait for it to finish going to sleep too, which usually is slower than coming out.

Windows XP

Once again, sleep is readily available from your power options dialog.

Vista

Your sleep setting is in Edit Plan Settings with the “Turn off the Display” setting.