i dislike the fact that the eclipse tool bar "debug" button doesn't actually run the debug profile in slot one just by clicking on it. i have to use the pull down menu instead. wtf?

frp keeps getting better, i wish i had time to learn and experiment.

nerd up!

here's another freaking genius art idea i'm just giving away: Louis Armstrong does covers of classic Ice T / Bodycount tunes.

yes.

yes, i hate Microsoft Word.

small example of why: i'm trying to position the text caret cursor at the end of a paragraph. the mouse pointer is on the line, to the right of the end of the text. i click. it doesn't put the caret at the end. instead, it selects the whole line. so i have to get the mouse cursor right at the end of the text manually. yeah, doing things manually is precisely what i want my software to force me to do.

the weird thing is that word does a pretty decent job of other, more complex, things like cutting and pasting sentences - correcting the spacing on its own. so why the heck couldn't they get basic mouse cursor usability right? blah.

whoever is responsible for the "Go Into" thing in Eclipse really nidz killt.

i think Einstein's quote is rolling in its grave.

ok this is probably a bad idea, but sometimes i wish i could use a partial namespace in java. so if i'd imported only "a.b" and needed to use "a.b.c.Thing", i could say something like ".c.Thing" or "...c.Thing" or whatever.

i wonder: is it easier to retroactively add unit testing to FP than OO? with OO if you didn't write things to be testable from the get-go, you can be sorta sol. sure, you can use things like EasyMock or whatever but it seems like a lot of magic overkill. i think it is because in OO you shatter the data and distribute it around various objects, which can be confusing and hard to follow, and which can also lead to making somewhat hidden dependencies on ever more stuff.

look, if you are going to do STM in anything other than Haskell, don't come crying to moi when somebody does something in a transaction that is actually an evil side-effect.

i've always had a soft spot in my heart for Baer's story but never knew that Bushnell is such a weasel.

wow. could i love the Reg any more?

ok, a little bit of genius about how everything around us can ostensibly kill us.

wow.

i! loathe! visual! studio!

one word: NestedContentProject.

ok, maybe some other words, too, like: trying to add files that are in filesystem folders to your project such that the project also has those folders in it. (hint: don't use the ide, use emacs to edit the .csproj file!)

i mean, not that i don't loathe all IDEs one way or another. but the fact that it is from MSFT of course adds a certain je ne sais quoi to the whole experience of hayte, ya know?

so many good ideas, so hateful a licensing scheme.

hey, good thing the days of voting fraud are oh so over, right?

so... somebody who fires people, knows the people being fired aren't taking advantage of their rights, and... can live with themselves?

so i had a vs2005 project. i opened it in vs2008. the conversion failed. now the project is effed up completely and i can't use it in either one any more.

so that's really a great way for Microsoft to earn my favour.

uh, i like how netbeans 6.1 freaks out when i alt-tab away from its "plugins" window; it doesn't repaint thereafter?!

<time passes>
<time passes>
<time passes>

ah, now it is back. yeah. impressive.

so, how does one actually refactor a db?

i think basically i want all my machines to run some standard virtualization system, and then have them all run some standard OS and environment on top of that, and then have them all keep things like shell configurations in some networked repository so that when i add some feature to e.g. my .bashrc it is easy to have it show up on other machines i might later on log in to. sort of like if they were all just dumb terminals to a central machine, only not. capice? (i'd probably run some Linux or *BSD rather than windows or os x (go go psystar! maybe you'll make it so we can totally use os x); could always run those in another vm partition if needed.)

why don't code editors have a feature (that i've noticed in emacs or eclipse) that looks at the format of a file you've opened and automatically derives formatting settings from it, so when you enter new code or rework things, the formatting isn't radically altered (because what you have as your default formatting is different than what the previous developers used)?

what is provably unknowable?
how close can you get to knowing it?
what if you change the assumptions in some way (e.g. don't be turning complete)?

mmm, 20 days of Clojure. (given that i don't get any sleep these days i think it will be a long time before i even get to go through Day 1.) the cute thing is that it goes through SICP, with video! and, remember, wanting it to run faster is not enough to get some sort of new free lunch via parallelism.

so monads are neat, but how do you know when to create and use them?

news flash: concurrency is still hard.

computer law gone wild! and not in a good way.

so. riddle me this. how does one successfully write and debug complicated stateful combinatorically long running code? like, how can you do correct-by-construction there?

all i'm saying is: if you make a scripting language, hows about including a debugging feature where the interpreter can log the script statements it is evaluating as it goes along? seems like it would be simple enough, and could help see where things are going awry?

i know nobody thinks they have the luxury, but still: what if we approached the design and implementation of things with a primary criteria of keeping everybody's day job experience as clean and fun and creative and forward-moving as possible?

in my ideal world, i'd rather spend the energy trying to get closer to correct by construction up front, rather than on debugging into existence later.

i probably won't always take my own advice, but face it: we know enough now to more often than not do our best to avoid static variables. use, instead, instance variables which are initialized via factory, not via new(). that way you have extreme flexibility in the future.

global climate change is real. oh, no it isn't! oh, yes it is!

summary: unvetted is bad, if you want Quality.

NEWS FLASH:

i!

hate!

blogger!

:-P

i want a way to say in code "if that last bunch of code resulted in value x, then dump all the logging for that last bunch of code."

there are probably more cases of putt's law being true than there are exceptions to prove the rule. having been a manager, i think it is true that if you think you are doing a good job, or know what is going on, you are most likely missing something significant!

it never ceases to make me hate, when a web site is apparently designed not for usability, but for showing ads. like, how many clicks does it take to just freaking download something from sourceforge? i really don't think it has to be the way it is.

oookay. pretty impressive when a new version of an ide fails to upgrade the old projects you were using. as if they were not created with the same product, or something. ass-hats all 'round.

yeah, i hate it when i'm trying to debug my processing of an XML file in Java and all the objects which are used to process the file are quite opaque lazy evaluated delayed thrice removed whatchimajiggers, so i can't actually see where the eff anything is as i step along in the debugger. i just have to keep tweaking the source code and trying it all over again, hoping to magically stumble upon the right collection of ACSII.

it isn't a surprise that MSFTian products kinda have issues, but i still scratch my head every time trying to navigate through the start menu becomes an exercise in waiting for XP to hit the hard drive and slowly slowly slowly figure out what it should be drawing in the menus. it isn't really the start button, it is more the "uh, waitasecond!" button. aaaaarrrrrrrggggghhhhhh!

(the kicker is that it takes so long to bring up the control panels list, too - i really think people don't un/install control panels as often as they do applications.)

it sure is great when the development tools turn out to be causing trouble: i can run either the release or debug executable just fine from the command line, but when i run the executable from the IDE it is super pokey stuttery not-very-responsive lameness in spades. thanks. yeah. spaß!

yes, but is it art?

if you can't write a set of really good solid tight tests for the way you intend to write the feature, maybe you shouldn't write it that way. (of course, assuming you are writing tests at all is often a lot to ask for, let alone writing "good solid tight" ones.)

somebody come up with a good interview question which lets me find out how the interviewee reacts when somebody comes to them and tells them that something they made didn't make sense. classic thing being user interface / usability issues.

like, do they say "oh ok, i guess that means i should fix that since the user is most always right", or do they say "ha ha, well now you know how the computer wants you to do the thing you wanted to do, so problem solved and i won't bother to 'fix' this for anybody else."

as far as i can tell, entirely too many people fall into the latter category. and i don't like that.

(i have fallen into that category once or twice myself, but i'm at least making an attempt to be aware of it and be even more of the proactive-listen-to-the-user side!)

some REPLs have ways to refer to previous values. "the" and "it" in muSE are pretty cute takes on that idea.

wish i could put money on Erlang.

i guess ben and gerry's went corporate-native and fired their plant and workers, so that's a nice f-u, there?

ah, yes, salvation for the lactose intolerant!

probably my favourite y! answer, ever.

i don't grok other people's ui choices. like, Paint.NET is up to version something-or-other, and yet as far as i can tell it does not have a square brush option for the eraser. !?

i kinda hate anything which went through the legal process. i mean, if we actually wanted people to have family time off, couldn't we make it not be a maze of rules? but then what would all the politicians and lawyers have to do, i guess.

i'm rather befuddled and surprised to not find an answer yet: how do you concatenate two lists in C# 2.0?

oh. because IList doesn't have it, but List does. yeah, ok.

i particularly hate the use of what are i guess iframes in the msdn pages. like, so i can't just use the space bar to scroll the page because when i click on the main body text i'm apparently not really, no, it is some other frame or something which doesn't then scroll the page. or maybe firefox is to blame. or just the whole blasted computer world in general. or perhaps just 'progress' as people seem to think all of this is.

why is it that people who write documentation for graphics apis seem to rarely document which of alpha=0% or alpha=100% is opaque or transparent? bleck! or even, sometimes, say what the range is so you don't know if 100% is 1.0 or 255 or what!?

there are times when the C# restriction that the underlying field must not have more restrictive accessibility than the related property bugs me.

i can appreciate the general philosophical aesthetic, but honestly i don't actually enjoy having "sudo port install darcs" end up downloading, building, and installing: curl, gmp, perl... ghc... still ghc... ghc not yet done... ghc... ha ha, ahem, cough, splutter. i'm much less of a gentoo emerge person and more of an ubuntu synaptic (modulo ssl ha ha sadness) person.

especially since the port install locked up and i tried to kill it and now i'm in a world of effed-up software. gosh, thanks, computer industry in general! way to go!

i dunno why computer software environments are still such a complete piece of excrementally hellacious version hell. as if everybody really enjoys going through all the exercises of having incompatible this that and the other every time they try to build something from source?

and then having to figure out if there is any way to get the machine back to some sane state, rather than some effed-up deal? hayte!

god, hell. the computer world sucks. i hate everything. well, at the very least i hate { mac ports + ghc + darcs }, at least as much as that unholy alliance apparently hates me. 'dyld: Library not loaded: GMP.framework/Versions/A/GMP' indeed.

some day i'd like to experiment with BitC (or Cyclone) to C to NestedVM-java-bytecode to IKVM. tee hee! (i did just get 'hello world' to work, so nestedvm isn't entirely hot air.)

i swear, that's like the third time today the Gertie has come up.

you have to love standards, especially all the web ones, and all the compatibility you get to see across all those different browsers, tra la.

on scalability: 'In fact, the recomendation is that instead of spending your time rewriting your app to use fibers (and it IS a rewrite), instead it's better to rearchitect your app to use a "minimal context" model - instead of maintaining the state of your server on the stack, maintain it in a small data structure, and have that structure drive a small one-thread-per-cpu state machine. You'll still have the issue of unexpected blocking points (you call malloc and malloc blocks accessing the heap critical section), but that issue exists regardless of how your app's architected.

If you're designing a scalable application, you need to architect your application to minimize the number of context switches, so it's critical that you not add unnecessary context switches to your app (like queuing a request to a worker thread, then block on the request (which forces the OS to switch to the worker, then back to the original thread)).'

one reason to try to follow the Law of Demeter is that the longer the code, the easier it is to have typos and/or thinkos. so if i have to say a.getB().getC().getD().doThing() instead of a.doThing(), there's all that extra ASCII that can go wrong. also, having to spend any effort thinking about getC() and getD() means the thinking can go wrong.

here's a tension i wish my software development environment helped me deal with: when developing code, i want it to have nice separation of concerns; i want a given function to have only what data it needs rather than be unnecessarily joined to some larger context. but when it comes to debugging, i want to see the whole bloody state, right? and i can't easily add a logging statement at the bottom of the call stack because that function only has the smallest slice of the whole picture. so how do i see/log the bigger picture so i can better understand so i can better debug things?

is ZFS + Flash too good to be true? i hope not.

another reason to keep it general: the more tightly coupled and hacky things are, the more you are going to have to mightily and painfully rework things when it comes to performance tweaking time. sure, some amount of generality will eat up performance, so as with all things it is a matter of degree, and of experience, and of iteration.

how to be really productive (apparently). nice one!

word: "When you ask people to envision everything that can possibly go wrong, their schedule gets a lot closer to reality - but still not close enough."

and i mean classic. (can you say, "teledildonics"? good, i knew you could!)

several folks, from experience, write to say: beware persistent state! as seen in game systems, flight systems, and in academia.

there's what i want to do with my life, and then there's what is realistic (and, well, legal).

hey! it just happened again! "Conflicting edits. There was more than one attempt to edit this resource at the same time. This may have been because you double clicked on a link or a button or because someone else is also editing this blog or post."

or, gosh, maybe because Blogger sucks? (or maybe somebody got my ykw.)

unless somebody has hacked my password (not impossible of course), blogger is insane: it just said there was a concurrent attempt to edit things. but i'm the only one editing right now, and only from this machine. so that's great usability and very reassuring.

one thing to consider when making some part of a system is: how easy will it be for future folks to have to deal with it? the more complicated or hard-to-use, the more energy should be invested in getting it right the first time. for example, if the system is handling some subset of large data and that data is not easily found or handled, then i'd suggest that particular system should be written in a robust fashion: plenty of tests, good design, lots of review by other people, have good tools which help ameliorate the difficulty of getting and examining the data, etc.

a resulting thought is that one should strive to find a way to break things down and simplify and constrain. the more atomic and separable and componentized the part, the easier it will be to examine individual parts in the future, non?

good code has concepts, and enforces those concepts. i think the fp-academic world approaches things more from that direction than i feel industry (omitting Praxis and ilk) does. which is sort of odd because one could think that OO would better lead folks to encode concepts. so in the end i think the adage that any tool can be used foolishly is strongly valid. you need to find folks who have a solid approach to begin with.

As somebody smarter and more famous than I has written, "I am happy with the discussion of the programming process with the emphasis on data structures and invariances to be maintained, rather than the details of the code. Doug Klunder, who wrote most of Excel, was great at that. Again, I am amazed how programmers today still start writing complex code when solving a problem without ever deciding what the state is and what the invariances are. OOP should have helped in this regard, but unfortunately it just created a separate focus to the methods which then give the programmers an illusion of orderly progress."

maybe educat-ion/ors could learn a thing or two from games.

it is duh time for game art folks. and maybe a little less duh for game-play.

hm. databases are hard? throw some fun fun orm into the mix! yeah, KTHX BYE!

it sucks that when debugging a remote Java program under Eclipse, i can't move the 'next statement' cursor around e.g. to replay something i should have stepped in to.

as many people, like Scott Meyers, have said at great length: paraphrasing Barbie, equals is hard. funny, huh? there are various suggestions on how to do it right. but they don't resolve the question: what does equal() mean, even?

i don't grok why Eclipse insists on putting "abstract" in all the signatures of an interface!?

i know the financial reality of the world is too harsh to allow this, but i think it would be nifty if one could have a software dev situation where the quality of the code and the happiness of the people were more important than appearances of making progress. it just seems to me that technical debt is not something with a big enough weighting factor in people's decision making processes.

ok. here's the - one of the several, really - thing which kills me about the design of Java: some Java luminaries claim that the language is designed for ease of maintenance! i think the inherent verbosity and lack of support for certain abstractions mean that it is, in several ways, anything but. part of maintenance is understanding, and the more ASCII cruft that gets between the human and the ideas supposedly encoded in the code, the worse off the maintainer is.

[broken record...] writing good code is not easy. the YAGNI and "the simplest thing which could possibly work" should, if you want to get anywhere fun in life, not be license to write crappy code. it should be about erring more on the side of generality so that the inevitable change in requirements won't be such a killer. i think functional programmers have something of a leg up because there is more of a focus on compositional approaches to software construction than i think exists in the OO world. not to say it doesn't ever exist there, just that the culture doesn't seem to stress it enough, even what with all the design patterns and stuff. to some degree i do think that it is because some of the popular OO languages like Java, and to an ever decreasing extent C#, don't give you a nice way to really do compositional approaches without lots of really rather heinous boilerplate. type inference can help a lot in that direction as well. (ok, ok, maybe it is only Java that is the stinking pile of poo what with anonymous delegates in C# 2.0, and better beyond.)

random e.g. from scary code: just because thing A uses thing B doesn't mean that thing B must at the same "atomicity" as thing A; you might - gosh - eventually need to use thing B in some fashion that is not lock-step with thing A. some might think that the more fundamental thing A is to your overall model the less dangerous it is to wire thing B along the same lines, because supposedly you already set a big stake in the ground that thing A won't change... shyeah, right, good luck with that, there, buddy.

random other lesson from scary code: the more you let yourself just bung multiple concerns together in a module / object, the more utterly doomed you are when it comes to refactoring later on. (maybe if at lest your unit tests really don't suck you can more safely get away with it, tho.)

also? Rather Useful Suggestion of Demeter?

also? the more complicated the thing you are coding up, the more important it is to build it in a atom/component/composition style. while OO's encapsulation is supposedly so great, it does still let people write macaroni code and yet seemingly think they are doing a great job just because things are in objects.

(not that i don't live in a glass house, myself, to be honest. i just hope to live and learn.)

i wish Java did a better job of helping you, rather than leaving you to have to do a lot of ASCII typing. e.g. 'final' doesn't work with abstraction because you can't abstract the common constructor code out to another method. so then i guess you'd have to do a builder/factory wrapper. which is a lot more effort. so in the end most people, i suspect, just skip the 'final' part.

genius nerd genealogy.

all i'm saying is, usability is hard, or everybody sucks. i think it is clearly confusing that the "rank" rows suddenly turn into raw count columns, when the "level" rows in the second case look too much like the "rank" rows of the first one, even though they really aren't related. grn.

mmm, scrum.

funny, i sorta sometimes liked IS but didn't know they did an easter egg hunt.

if cygwin is killing you, apparently (i have yet to try it) the msft competition is better. although i wouldn't go so far as to buy everything they call "facts".

neat! parallels decided to peg this dual core macbookpro's cpus over night because it had up a dialog box asking me if i wanted some usb thing which it thought had been connected to the machine to be connected to parallels as well. when i figured out that it was parallels and switched to it and clicked on the dialog box to say "no", the cpus then went back to normal ~30%.

the funny cherry on top is that it happens even if the VM is paused. so it is apparently just the Parallels 'framework' that is in some god-awful tight-spin-loop.

hey firefox 3, thanks for not responding to the page up / down keys in my long list of bookmarks in the bookmarks application menu bar menu!

We look hard
We look through
We look hard to see for real
Such things I hear, they don't make sense
I don't see much evidence
I don't feel.

i think that, actually, the original point is more valid than thought, because it sounds like O'Caml really does let you stay away from Objects, which lets you stay away from all the mostly-ignored questions which come along with them. like, do you use inheritance? do you try to respect the LSP? can you not have fragile base classes? yadda³. so, if you really grok O'Caml, it sounds like you really do avoid OO as much as possible. (i've heard that from more sources than just Harrop.)

hey! learn fp already. i mean, all those msftians are ahead of you, now! and the dod!

is it just me, or are Properties in C# kinda a weird mish-mash pain in the ass? when is/shouldbe something done as a Property vs. when is it done as a method? yeah, smoke a bowl and figure that one out. or, why they didn't have a Set type. i guess it was an homage to Perl.

vanilla << french vanilla << cookies 'n' cream.

if an impressionable youth were to decide what career to choose based on web site clip art, and with an eye towards future dating potentials, i dare say said youth could end up in customer service. oh, and move to arizona. i mean, well, shoot!

i suspect it is all big fat lies.

i think i want strongtalk. or something with gradual typing. maybe newspeak? but then i want it to be able to talk to .Net and JVM libraries...

supposedly we have something of a programming language renaissance going on in that there are lots more languages around, seemingly. from the java/C#s of the world to the erlangs to the rubys or factors or whatever.

and yet i find there hasn't been a language which is what i want. not that i'm 100% sure what i want, which is part of the problem, but one thing for sure is that i want it to be able to target both the JVM and the CLR.

i tried Fan, but the compiler was dead dog slow, so that sucked. and besides, it doesn't let me call java/.net dlls easily.

word: 'Some might say "Just don't call the method Add; call it Combine or something instead." That would indeed avoid the problem. But it also points out the root of the flaw in this assumption: it should never be the compiler's job to assign semantic meaning to identifier names. Some languages do this. However, it has always been a strength of C-style languages that the developer has complete control over his own code, and can create whatever implementation he deems appropriate to the circumstances. What if Add makes the most sense in my situation, but my class isn't actually a collection? Or what if it is a collection, but I don't want to call the method Add, because Enqueue or Push would be more appropriate?'

uh oh! i think i'm starting to get an itch for something like Smalltalk. in particular, i'm realizing the pain of trying to do dynamic and flexible things the more ossified-static languages like Java and C#. like, how it would kinda suck to have to try to roll your own dynamism in those languages, because in the end you'd end up with something that feels just really gross and hacky, and just going against the grain a lot. (mind you, things like java beans with their get/set mentality already sorta break the ice.)

but, basically, if you are doing experimental development then the point is that you don't know ahead of time what you will need, which means you end up wanting everything to be public and alterable so you can muck with it on the fly, vs. the "oh that's private i guess i will have to go through another edit-compile-run cycle, since getting edit-and-continue to work has been less than easypeasy."

which brings me to the suck of making publicly-read-only (but which might be editable internally to the class) member variables. i'd like a language with a very concise way of doing that, rather than the ASCII bloated approaches of Java or C#.

visual studio express edition 2005 might be better for C# development than eclipse, i haven't really tried eclipse for much other than java. but the overall vs application itself suffers when compared to eclipse. which is sorta surprising to me since eclipse can really drive me up the wall, often. but i find some good, basic, features in eclipse that don't exist in vs which gets to be pretty annoying pretty quickly.

hey, good thing President Bush wants to wiretap us all even more, as if the rape of civil rights hadn't gone far enough already.

horrible, horrible, shame.

a nice homage to OMM.

i do not understand how Apple seems to be loved by developers when they can't get a decent story about Java or X11 going, ever. i realize those aren't core Apple-specific technologies, so maybe it is only pure Cocoa developers with the boners for AAPL?

yes, Thunderbird sucks buttocks. but it was a lesser evil than Zimbra. imagine that!

every time i am faced with the classic Microsoft menu entries of "Customize..." and "Options..." i wonder how MSFT could have gotten where they are today.

perhaps even encapsulation should be taken with a grain of salt, even though the OO frenzy would seem to claim otherwise.

eventually we'll be able to scrap all code, ha ha! not.

multi-core is something of a question mark when it comes to software development. things like Erlang and the latest Mozart and Haskell STM and Clojure help think about it. apparently, if you take the right approach, O'Caml is not to be left out, either.

arg, too much to read, as ever. i always like to read what Stroustrup says because even though his products are sorta insane, he seems to always sound really sane. (I like to read what Bertrand Meyer has to say in a similar way.)

Stroustrup: "If you look at some of the most successful C++ code, especially as related to general resource management, you tend to find that destructors are central to the design and indispensible. I suspect that the destructor will come to be seen as the most important individual contribution - all else relies on combinations of language features and techniques in the support of a programming style or combinations of programming styles." ... and more interesting stuff on proper resource management.

Although I'd still vote for using Ada over C++ when making machines that kill. Oh, wait, maybe if Skynet is C++ it won't win!

have some fun with the MISC experimental programming language.

is there a reason i can't right-click on a folder in the finder to search in there? +1 windows.

i hate os x. i hate adobe. the claim that you can just drag and drop an application bundle to install it has been exposed as something of a big fat stinkin' lie. over and over.

language design is hard. c# bugs me because it starts to go some way towards something, and then stops along the way. like, you can't have static indexers.

enums in C#/CLR are pretty gosh-darned lame. presumably somewhat because they have to be compatible with managed C++ enums which must be backwards-compatible-ish with old C++ enums? super suck.

i wish Java/C# compilers did a better job of warning you when a local variable shadows an instance one, if the local one doesn't have "this." explicitly prefixed.

so funny i forgot to laugh. yeah, love that warm hug feeling from msft.

oh, no wonder i sorta distrust the mod operator.

sure, it is good that people are rediscovering functional style, but i often get the feeling that implicitly people are also saying they wouldn't believe in it until MSFT or JAVA said it was real. almost as if the ideas didn't even exist before then.

probably not the direct cause, but the startup sound on the SGI Indy is enough to make any sane person not want to ever turn the thing on again.

it makes me mad that debuggers mostly still kinda suck a lot. like, is there an easy way to set a breakpoint that will only break for a specific stack trace, or only for a specific object? generally i think no - you set a breakpoint and then have to mentally do the work to figure out when you can click to continue vs. actually study what is happening because it is the runtime event you really want. blah!

erlang is more than just message passing, it is the OTP which makes for a nine-nines system. it would be a great service for somebody to interview the elite of various systems (erlang, haskell, aliceml, etc.) to try to extract the essential from the incidental, and get the essential stuff written down with discourse on why it is essential and how it all hangs together. that way new folks could more easily learn the core concepts, and apply them in other situations, and folks could start to think about how to extract them without the baggage that evolved along with it originally.

the way i've been eating recently makes me wonder: can a person go to hell based solely on their eating habits? (and, no, i am not into cannibalism all of a sudden. i'm talking abut your regular run-of-the-mill evil diet, familiar to all too many 1st worlders [a term which i find obnoxious since in some ways it should really be read as 'earth rapists'].)

microsoft's 'free' visual studio 2005 C# thingy is pretty much killing me. the window layout with tabs and things is ignoring what i tell it and is resetting to some entirely hateful layout. so that's a lot of fun. it didn't start out this way, but has somehow gotten itself into this tizzy of a state. sorta like how ms word can get all effed up. seems to be a nice msft trademark for their applications?

ah. after screwing around with it, it appears to be something about how they do stuff with tabbed vs. dockable windows. whatever.

all we are saying is, time in .Net is kind of a mess. legacy?