bc-programming

It’s a relatively trivial task, really easy to do with the command prompt and GNU wc:   for /f "delims=" %P in (‘dir /s /b *.cs’) do wc -l "%P"...

It’s a relatively trivial task, really easy to do with the command prompt and GNU wc:

I executed this within the desired directory (my BASeBlock source folder, if you must know) and the result was a file filled with numbers and files; I wrote a quick python script to parse that and add up the numbers that were at the start of each line, but then I figured, why not just write the whole think in python and forget about the rest of it, so I did.

It’s a rather basic script, and I don’t even comment it as much as I ought to. I just wanted a quick tool to be able to count the lines of code in a given directory for a given source file type. Ideally, I’d allow for multiple types, but I didn’t want to complicate the argument parsing code too much. The counting method is pretty barren, it just loops over every line and increments a counter. It seems to work relatively fast. It quickly gave me the result I wanted, which was that BASeBlock’s .cs files comprise about 53K lines of code, excluding the .designer.cs files (thus the third argument). And now I have a nice reusable script to figure this out in a jiffy without too much thinking about shell syntax or what I need to pipe to wc and what arguments I need to pass wc and whatnot. plonked in a location on my windows machine with pathext set to allow execution of .py files directly using the ActivePython interpreter and putting it on my Linux machine and adding a symlink in /usr/bin to it makes it available to me on both machines.

So, as mentioned in the previous post, I added a “sort” of scriptability to BASeBlock. I made some tweaks, and refactored the code so it was a bit more abstracted;...

So, as mentioned in the previous post, I added a “sort” of scriptability to BASeBlock.

I made some tweaks, and refactored the code so it was a bit more abstracted; the original implementation was directly in the MultiTypeManager, but that didn’t really have anything to do with it, so I tweaked some of the parameters to a few methods there, added a new class with the static routines required for the needed functionality, etc. I also made it so that a “BASeBlock Script Group file” (.bbsg extension) could be used to both compile a set of files into an assembly, as well as include various other assemblies as required. Future additions will probably include the ability for each assembly to define a sort of “main” method, which can be called when the assembly is initialized.

However, once again, Serialization was the constant thorn in my side. I was able to mess about with a custom block written in a .cs script, and it even saved properly.

But the game encountered an exception when I tried to open that LevelSet; I forget the specifics, something to the tune of “failed to find assembly”  type of error. What could I do?

 SerializationBinder

What this basically meant was I was going to have to learn even more about the Serialization structure of .NET. Specifically, SerializationBinder’s. The concept was actually quite simple. You basically just derive a type from SerializationBinder, and use that as the .Binder property on a IFormatter class, overriding one method seems to be enough for the most part:

Simple! it gives you an assembly Name, a Type Name, and you simply return the appropriate type. The reason the default implementation wasn’t working was certainly as a result of the assembly being loaded dynamically, since it wasn’t [i] really [/i] being referenced by the BASeBlock assembly, so the default implementation didn’t find the “plugin” class assembly or the appropriate type, so threw an exception.

The trick here is not to enumerate the referenced assemblies, but rather to use all loaded assemblies in the current AppDomain. The general consensus with regards to using CodeDOM and compiling things like this is to compile them to their own AppDomain; however, since the assemblies were being kept “alive” for the duration of the application, that wasn’t necessary, and in this case would have complicated things. Well, it would have complicated things more than they already were.

The “AssemblyName” parameter, however, was more akin to the FullName property of the System.Reflection.Assembly; for example, BASeBlock’s assembly would (for the current version) be passed in as “BASeBlock, Version=1.4.0.0, Culture=neutral, PublicKeyToken=null”. Since we are only interested in the actual name of the assembly, we can simply grab everything up to the first comma.

Armed with the Assembly’s base name, we can start enumerating all the loaded Assemblies and looking for a match:

Then, we compare the Assembly.FullName.Split(‘,’) [0] (the text before the first comma) to the modified string, BaseAssemblyName that was changed in the same manner. I decided to go string insensitive for no reason; mostly because the assembly names for the scripts are formed from the filenames and I wouldn’t want filename capitalization to prevent a script from serializing/deserializing properly. If we find a matching assembly, we return the result of a GetType() call to that assembly with the same typename passed in as a parameter to the method. The Formatter will than attempt to deserialize the data it has to that type as needed.

There are a few issues with this- for one thing, it doesn’t work with Generic types. At least, I assume it doesn’t; I assume I would need some special code to get the appropriate Type for a generic type given type arguments. I’ll cross that bridge when I come to it.

Right now, I’ve not actually tested this extensively. My main concern would be to test that it can serialize in one session, and deserialize in another. This concern is based on the fact that the two assemblies would in that case be literally distinct- in that it would have been compiled on two occasions. Assuming the Binder is enough to convince the serializer it can deserialize something, there shouldn’t be any issues. Once I decide to figure out how to add Generics support to this Binder, I’ll definitely write about it here.

When I first started developing BASeBlock, the basic idea was just to get a feel for how Animation, rendering, and other concepts were dealt with in C#, as opposed to...

When I first started developing BASeBlock, the basic idea was just to get a feel for how Animation, rendering, and other concepts were dealt with in C#, as opposed to the aging language I was familiar with VB6. Additionally, I wanted to make use of Threading. After getting through the initial hurdles and issues related to the type of code I would need to write with BCDodger, I had a good idea the type of things I needed for BASeBlock.

BASeBlock’s actual Game information is, not surprisingly, kept inside a instance of a “BCBlockGameState” object. There are a few folly’s in my design, whereby some elements that would probably be best placed as members of BCBlockGameState are in fact members of the main form, but everything works well as it is, and if necessary objects can get a reference to the form itself using the BCBlockGameState ClientObject property, which is a interface that defines the type of stuff that is more implementation specific than ought to be in the State instance. Rendering is managed entirely within the Paint event of the main form’s PictureBox- (and likewise for the Editor). Rendering and the actual GameProc() routine (that makes things happen) are similar; they both iterate through the various objects in the game and call methods. The GameProc() routine animates balls, GameObjects, Particles, and AnimatedBlocks; the Paint event basically iterates through all those objects and get’s them to paint on a bitmap which is them blitted to the PictureBox when necessary. Of course having these two activities on separate threads meant  that I tripped on a few things while I was getting started- not locking this variable, trying to call methods of the form from within the game loop, and other similar contention issues. All of those have been resolved, to the best of my knowledge.

Another goal while working on BASeBlock was to make it easier for the creation of new blocks. The way the older Poing game (VB6) did it was to only have a single Block object, which had an Enumeration that determined what kind of block it really was. This had the issue whereby the Block had a lot of fields that were only applicable with certain block types, and weren’t applicable at all otherwise. This was a primarily a result of the fact that VB6 isn’t really an Object Oriented Language, but rather an Object-Based Language; while you can fake Implementation Inheritance using the Implements keyword and an aggregate class, it’s a lot of boilerplate that I couldn’t be bothered with for little gain. With C#, and more importantly proper OOP constructs, I could try my hand at a more reasonable Object heirarchy.

Collections

By far one of the most annoying things to deal with in VB6 is collections. they are finicky, and more importantly, the built-in Collection class only deals with Objects, so I would have to cast variables all over the place, and casting in VB6 means actually declaring another variable of that type and using Set to attempt the assignment to perform the “cast”. The only “workaround” is to create a entirely new class that uses a Collection internally but exposes the members of that Collection as the more specific type, as well as having Strongly-Typed parameters for Addition of blocks and removal. But the creation of these classes:

• Is a gigantic pain in the ass. They are almost all exactly the same, differing only in the Type used.
• Clouds the namespace. Poing has a Levels.cls class, a Blocks.cls class, a Balls.cls class, and a few others, all for the sole purpose of representing the exact same data structure for different objects.
• Is a gigantic pain in the ass. I already said that, but I just wanted to make sure I was clear about that.
• While you can use For…Each on the collection, it’s only through non-standard coding and setting method properties that it works, and even then you have very little control since the Interface being used for Enumeration, IEnumVariant is not easily implemented in VB6, and requires literally hacking away at your Process Memory to change in-memory VTables, which wreaks havoc on the brittle IDE.

Now, thanks to my Switch-over to C#, I can just declare those variables to be List<Block> or List<Level> or List<cBall> and forget about all this special Collection class nonsense. And Of course for specific Data Structures, I can use various other Generic classes such as Stack<>, LinkedList<>, etc. Generics is a powerful feature that becomes that much more valuable when you’ve had to hoof it yourself in less powerful languages to duplicate it’s functionality.

Dynamic Loading

But, this is supposed to be about dynamic loading- and more specifically, Reflection. Visual Basic 6 sorta-kinda had reflection, in the form of a MS-provided library, tlbinfo32.dll, which essentially allowed you to inspect COM components; since VB6 produced COM components, this worked there. But it was still rather cumbersome; you were no longer looking at VB-native classes or types, but you had to interpret the appropriate parameters from the idl code. additionally, COM was often just plain stubborn. I feel that in many ways .NET tries to resolve the issues of COM, particular with regards to pluggable components. .NET allows you to, directly in your code, load a new assembly, inspect the classes and types within that assembly- see what those classes implement or derive from, and so forth. Java provides equal functionality with it’s reflection libraries, too, and  that is how a lot of java applications implement plugins, including eclipse, one of the better java IDE applications.

With C# & .NET, you can load assemblies directly from the .dll or .exe file; then you have the Assembly object, and can inspect the types of t hat Object. BASeBlock, for example, loads all the assemblies (that don’t meet an “ignore” regular expression) from it’s executable’s folder- I’ll probably change this to a unique location, to prevent the game from enumerating the assemblies I included which will never contain what it is looking for). Once it has all the assemblies, it searches for various Types that implement some of it’s types. It always inspects “itself”, so it will find all the Block derivations, iBallBehaviour implementations, iPaddleBehaviour, etc. These get added to their own LoadedTypeManager instances within the MultiTypeManager that does all the work, and this allows the BASeBlock code to easily find all the implementations of it’s various interfaces, for purposes such as showing a pop-up menu and so forth.

Originally, I wanted to add a single implementation of the appropriate interfaces and base classes,  that delegated their actions/events/etc to some sort of script interpreter/compiler. After futzing about with IronPython, however, I decided  that the object model exposed there and what I needed required a lot of plumbing code to make managable. But then I had another thought.

The CodeDOM

.NET Exposes a namespace, System.Runtime.CompilerServices that contains more namespaces, classes, and interfaces that are used for dealing with the CodeDOM; it also allows you to compile  VB.NET and C# (probably F#, but since that isn’t included in .NET 3.5, I don’t support it yet), directly into assemblies. That is when I realized I could use that functionality, paired with my existing code that finds object implementations and derived classes for an Assembly [] array, to make it possible to “script” new derived classes and implementations of those interfaces and Derivation I search for. The result turned out to be quite simple, not more than a page of code, which I added to the class that performed the Assembly enumeration. It loads new assemblies by inspecting a Scripts folder in it’s %appdata% folder, and attempting to compile those scripts into assemblies (.csx files using the C# code provider, .vb files using the VB code provider… I was going to use .vbx but that gave me flashbacks to Visual Basic 2.0 and vbx extension files. The code used to compile adds the basic references (System.Drawing, System.data.dll, etc) as well as itself, using Assembly.GetExecutingAssembly().Location- this includes the BASeBlock assembly, which is necessary since BASeBlock of course contains all the interfaces that need to be implemented, the necessary frameworks for any additional addins, etc. The script I used to test was a copy-paste of the AddBallBlock class, whose name I changed to AddBallBlockEx. Once the code compiles the new assembly and detects everything went well, that Assembly object is added to the list of Assemblies that the game will inspect for the appropriate derivations- of Block, iBallBehaviour,GamePowerUp etcetera.

After some tweaks and debug sessions, everything seemed to work fine. So far the only issue has been that AddBallBlock’s code called “AddScore” which is implemented by the Block base class, but for some reason trying to compile that resulted in the error that the symbol wasn’t defined. Absolutely no idea what is going on there… Once I resolve that issue, I’ll make the error-detection code a bit more robust and easier to get to  (for people trying to write their own scripts, or me in the future, it would be nice to have a place to find the errors issued by the compiler; perhaps it can save them in either the same scripts folder (as script.csx.errors or something) or a separate folder. As it is now, though, the test classes I created seem to be found perfectly fine; the blocks show up in the editor and the powerups can be spawned using cheats, so they seem to work well. the AddScore() issue will bother me though, but it seems to be related to the way the object heirarchy is laid out.

The main “unique” feature of BASeBlock is that it uses pure GDI+; this was because OpenGL seemed like overkill, and I needed to learn GDI+ at the time anyway. People don’t give it enough credit, honestly.

Well, I removed the Bidvertiser ads. They were everywhere and all over the page and extremely annoying. And I got zilch. Definitely feel taken advantage of. I&#8217;m going to try...

Well, I removed the Bidvertiser ads. They were everywhere and all over the page and extremely annoying. And I got zilch. Definitely feel taken advantage of.

I’m going to try other networks. I’d stick with adsense, but their ads don’t show for me; I guess they blocked me. Would have been great to have received some information about that, but oh well. With any luck I’ll be able to at least make enough to keep the site alive. 3 dollars a month cant be too much to ask from the advertisements. So the site is back to being “ad free” for a short while.

Testing out ads. Trying to make this site something that doesn&#8217;t need to be supported/hosted/paid for out of pocket. Feel like a total douche, but for the moment it&#8217;s just...

Testing out ads. Trying to make this site something that doesn’t need to be supported/hosted/paid for out of pocket.

Feel like a total douche, but for the moment it’s just an experiment.

What worries me is that they seem… well, a bit aggressive. I hope I don’t scare people away; not because they would equal more hits=more revenue, but because I like to try to deliver good content and with ads like this it’s hard to determine whether it is my content that drives people away or the advertisements.

Again though- just an experiment. I’ll see what the webstats say in a week or so, and whether it’s worth it. my experience with advertisements says no, but we’ll see, that’s what the experiment is for. Speaking of webstats, I don’t trust them. It says I’m getting 1K hits a day, but I doubt I break a couple dozen.

Oftentimes, when comparing software products in the same market, you&#8217;ll see comparisons made where one product has a &#8220;pro&#8221; over another based entirely on the fact that it doesn&#8217;t cost...

Oftentimes, when comparing software products in the same market, you’ll see comparisons made where one product has a “pro” over another based entirely on the fact that it doesn’t cost money.

I’ve never understood this. It doesn’t make any sense, when you think about it. Sure- if the two products are extremely similar in form and function, then the comparison is valid- because all other things are equal within a margin. But the problem is, when it comes to free software, they typically don’t stack up to commercial ‘evil’ proprietary Applications.

For me, I learned this by way of text editors. This is a very simple type of application, and one would assume that out of the bajillions of free offerings, one of them would also be easy to use, and meet my needs. This was the case, but I was stymied by what I found in a lot of them.

For example, I have often seen free, Open Source applications, such as emacs, vi, etc touted as “the de facto text editor” application, and held up as some kind of standard.

I have to be brutally honest here- if those are some sort of standard, then that is a pretty damned low bar.

VI

How is this even something to consider for everyday text editing? It’s about on par with WordStar in terms of finger-contorting shortcuts, and it reminds me of edlin, except that it is powerful; That much I can see. But when I need to become a god-damned apprentice to a ancient VI master to learn how to use the software application in a way that fits my needs and need to “train” myself even longer in order to do so adeptly, I’ve lost. My time is not valueless . It doesn’t matter if the software was free, or if I can edit the source code. For one thing, I don’t try to judge software as if being Open Source automatically makes a piece of software sit on some sort of moral high-ground above others. I want my software to work and do what I need . That is it. software should be judged on it’s own merits, not on it’s license.

One thing I noticed with free text editors, was they all seemed to have too many features, poorly organized.

notepad++ is a fine application. But it’s menus are an absolute mess. Being Open Source doesn’t mean you can ignore basic UI Design guidelines. Same goes for the Graphical versions of Vi/Vim (gvim) and for emacs. I have no doubt these are powerful tools, leveraged by plenty of people worldwide. But I cannot personally justify the time investment it would take to learn these applications, when there are plenty of other applications that provide exactly the functionality I want in an easy to use package. Also, from what I’ve seen, becoming proficient in either emacs or vi turns you into a condescending douchebag. gedit is a fine application- it’s free. It has syntax highlighting, and it’s menus actually make some bloody sense, and yet time and time again I see Linux veterans saying it is only for “noobs”. I want to edit my text. That’s what it does. The problem they have is that they invested so much time in learning an overall badly designed (UI-wise) application, and now need to justify that time investment by putting down those people who avoided that time investment in the interest of getting things done.

The free software I found that met my needs at that time was Editpad Classic. This program was (and is) a closed source application. I didn’t, and still do not care. It did what I needed. Then, when my needs grew, I found the same vendor had a product called “Editpad Lite”, and I found that to be sufficient as well.

When I started this website, I needed a efficient way to upload and edit files to and from my webhost. Upon reading the descriptions of features for that same company’s paid offering of the same product (Editpad Pro) I found it seemed to fit my needs perfectly.

Ever thrifty, however, I decided to prowl the web for free software with similar features. Notepad++ had an FTP plugin, but it was unweildy, stubborn, and finicky. No other FTP capability seemed to match. So I purchased Editpad Pro, and I am still using Editpad Pro (still using version 6) to this day for this very capability. Being able to make quick changes to my news page, edit the PHP code of any file on my host, at the touch of a single GUI button is something that I value. Again, I value my time more then some self-inflated sense of pride. Sure, I could:

1. download the appropriate file I want to edit using wget
2. edit the file using a powerful program like vi or emacs
3. use ftp to upload the file back to the server

But I cannot see any reason to do that. I can do all of those. But why are they disparate tasks? All I want to do is edit a file on my webhost. Why is it that an editor cannot edit a file simply because it happens to reside on a remote server? Why do I have to go through an arcane ritual of download->Edit->Return to sender just to edit a single file? And why do people seem to think this is in any way superior to the time-saving method of simply using an application that does this properly ?

Returning to Open Source; It’s fine! I have no problem with it at all. I plan to release BASeBlock’s source code under the BSD/MIT license. But I don’t feel that an application being open source gives it value. The fact that an application is Open Source, in fact, means absolutely nothing to me. I only care about whether it does what I want. I don’t care if it has the potential to do what I want if I make changes and recompile the program, because that means it’s not free at all, costing me time I could spend not editing somebody elses program. People often tout the “Open Source” label, as if it matters. It truly does not. In the majority of circumstances, you don’t need, and you do not sanely want to view and edit the source code. How many people can look at the source code for perl, and make sense of it- only the maintainers. That is their job; even if they volunteer, thats what they like to do. But Why would your average user want to recompile the perl interpreter? I can’t think of a good reason. Same for nearly any other Open Source application. I’ve never downloaded and used a Open Source application and thought “hmm, it’s missing this feature- I know, I’ll waste the next two weeks staying up until 2AM and adding it”. No, what I think is “Hmm, this software application is missing this feature, I know, I’ll stop wasting my time using it and find something that does”.

I think the best summary I can come up with is this- Being Free or Open Source does not excuse sub-par design and implementation; and, at least in my opinion, I don’t see a reason to use any application based entirely on it’s license or distribution method. It’s almost as arbitrary as using an application over another because one of them is written by a catholic and the other is written by a jew. It’s a arbitrary and irrelevant to the meat of the matter which is whether that software does what you need it to.

Serialization has always been a thorn in my side. In VB6. in Python, in C#. The biggest annoyance is that most applications consist of somewhat complex object relationships and heirarchy&#8217;s,...

Serialization has always been a thorn in my side. In VB6. in Python, in C#. The biggest annoyance is that most applications consist of somewhat complex object relationships and heirarchy’s, different race conditions about values that need to be initialized first, and who knows what else, all meticulously built during the course of your application, which you eventually need to save to persistent storage.

All applications can benefit from some form of persistence, even if it is only in the form of settings. As a result most Object Oriented languages have a way to allow you to “serialize” an object to a stream. In .NET, this is provided by way of the [Serializable] Attribute and the ISerializable interface, which allows you to customize the serialization somewhat.

What is interesting, at least in the case of .NET object serialization, is that you can choose one of a number of “Formatters” which will take the data acquired by the Serialization support framework and format it to one of any number of formats. Personally, I have only used The BinaryFormatter class, which will allow to write or read a serialized stream to or from a stream.

So, what use is serialization? Well, aside from the obvious ability to save the stream to a file, you can also use it in other ways. For example, since you can send the data across any stream, you could send it through a network stream, and on the other end another instance of your application would be able to rebuild the exact same object. Another usage I’ve found is for usage on the system clipboard; serialize what is being copied, plop it on the clipboard with your own format specifier, and then when you want to see if you can paste check if that specifier exists and when pasting deserialize that data from the clipboard, and you’ve got the objects that need to be pasted, which will be “new” objects separate from those copied (if they are still present).

Copying a object graph to stream, however, has a bit of boilerplate; you need to create the BinaryFormatter(), serialize, and the opposite in the other direction.

However, with generics, this task can be made a tad easier:

Two static methods that serve to input and output a object whose type implements ISerializable to and from a given stream. It also uses the GZipStream to compress and decompress that stream to try to save space.

Extending this directly to files is rather easy as well:

And huzzah! suddenly you can read and write objects to and from a file with ease.

One might even venture to create extension methods on the Stream class that provide this sort of functionality for input and output of any object supporting ISerializable, like the following, which assumes the previous routines are within a ‘ObjectStreaming’ class definition.

And there you have it, suddenly you can write objects directly to any stream, using methods of that stream Object, and that saved data is automatically GZipped for you as well.

This Does, however, present it’s own issues. If there is an error anywhere in your serialization code, using a “filter” type of stream, such as the GZipStream, may cause difficult to trace errors that cause exceptions to fire from the GZipStream itself, most notably “unexpected end of stream” type errors. You can usually trace these in Visual Studio by checking “thrown” on System.Runtime.Serialization.SerializationException in the Debug->Exceptions dialog, and allowing the data to save to a normal stream (that is, directly to a filestream or memory stream rather than by way of the GZipStream). This will allow you to determine where you made the mistake elsewhere. Typically, in my experience, it’s usually something as innocent as a misspelling, or even inconsistent capitalization.

So, I have an ancient laptop. A Toshiba Satellite 440CDX. I covered it in a youtube video: Basically, for modern purposes, it&#8217;s practically useless. However, it could still be usable...

So, I have an ancient laptop. A Toshiba Satellite 440CDX. I covered it in a youtube video:

Basically, for modern purposes, it’s practically useless. However, it could still be usable in some sense, I feel. So the first step was to get it network connected- it could, for example, server as a file server, or something.

The laptop is old enough- and I guess wasn’t the right model- that it doesn’t have a built-in Ethernet port. I don’t think it was typical in those days to have one, anyway. The only item that appears in the network adapters list of Device manager is the infrared port (remember those?). However, thankfully, it supports Cardbus. So I hopped on ebay and bought some cheap chinese thing for like 4 bucks. it took like 3 weeks to arrive but it made it.

I originally intended to create an “opening” video, where I set it up. I did, but I made an ass of myself by trying to plug the cardbus card in the Expresscard slot of my newer laptop for “testing” which of course didn’t work. Plugging it into the 440CDX- nothing happened. Was it defective? Wouldn’t be surprising, given the price. I perservered, because I guess I had nothing better to do.

I ended up in the laptops CMOS setup, and on a whim I toggled some PC-Card mode from “PCIC-compatible” to “Cardbus/16″ or something.

Upon rebooting, I plugged in the PC-Card… and Poof! Found new hardware appeared.

And thus began my trek to find it’s driver. The CD that came with the device was utterly useless since it was for a completely different component (judging from the INF files, a PC-card for serial/parallel ports, or something). What ended up happening, was I allowed the device to “fail” to install, and used Everest Home, at which point I discovered it was a Realtek chipset. This gave me something to work with. I first tried the closest model in the win98 database, which of course didn’t work, so I downloaded the appropriate driver. As I speak, it is installing now

. I needed to copy the contents of the Windows 98 CD to my flash drive. And I now realize that I used the Windows 98 First Edition disk contents rather than SE, so I’ll have to start the entire shebang again unfortunately. I ought to point out that the flash drive usage is supplemented by the incredibly awesome “unofficial service pack” for windows 98- that can be found here , and adds Generic Mass Storage drivers (whereas normally you would need a special driver for nearly every different drive you want to use). As well as a plethora of fixes/tweaks that make the Operating system as stable as possible. Which is very useful for systems that cannot run a newer OS.

Having now restarted the process with the appropriate(Win98SE) files, with any luck it will soon have network connectivity.

At which point I can forget about the entire thing and toss it back in a closet. But not after seeing how laughable the net is with IE 6 (or possibly 5.5). I might search for a more lightweight alternative but a Pentium 133 machine just isn’t cut out for the contents of the net today. I can’t imagine how terrible this site looks on it. At the very least I open up the possibility to use the laptop as a file server or something. Which would be pointless since it’s HD is tiny. SO some might ask “what was the point”? Well, actually, I did gain something so far:

I’ve now learned more about and actually used PC-Card type peripherals. While I was well aware of the various type I,II, III, etc designations, I was unclear as to the specific differences (PCMCIA on older machines being basically a portable ISA, PC-Card being PCI, and Express-Card being PCI-E). my ignorance shown quite completely by my attempts to plug a cardbus card into a expresscard slot. That, and I’ve now actually (well, with any luck) gotten one working, so there is that. The experience, I guess is the motivating factor. Also, it was totally worth it to hear the cool noise the laptop makes when you remove a PC-Card that it knows about. It’s like a PC-speaker version of the XP/Vista/7 “Device removed” sound. Hilarious, and fairly sure the BIOS is doing it too, which means that it’s really coming from the heart of the machine. Touching.

If the CD-ROM Drive of the machine still worked, I’d probably be testing out lightweight OSS Operating Systems, but unless I shell out 80 bucks for a new CD-ROM for the thing (haha, fat chance) that simply is not going to happen.

When choosing a font for any situation, you must consider the context of the font as well as it&#8217;s readability. Choosing a font for programming work is no exception. However,...

When choosing a font for any situation, you must consider the context of the font as well as it’s readability. Choosing a font for programming work is no exception. However, for the most part, programming fonts are blocky, and rigid; much like the source code  they are used to display. Traditionally, Monospaced fonts work best; I know people who use MS Sans Serif and it drives me nuts.

I’ll skip the prologue involving the TX-1 and PDP-1, PDP-7, and so forth. Let’s start with the first Personal Computer- the IBM PC. Naturally, this machine didn’t really have a concept of “fonts”. usually, any editing of text you would do- programming or otherwise- was done using the “System” font. This actually varied between systems. Typically, the font was actually stored in the video card, so different video cards could often yield different results.

To demonstrate a few select Programming fonts I have encountered in my internet travels, I will use Visual Studio 2008, and change the font, and take a screenshot of a small segment of code that I feel is “busy” enough.

System

Fig 1. A Typical System Font

Fig 1 shows this sample using the “System” Font. A few issues stick out for this font; first, it’s a tad too bold. It feels too “heavy” for use today, compared to other fonts. Also, it’s rather large; it  takes up an unnecessary amount of space. For the most part, nobody uses the System font for… well, anything, actually.

 FixedSys

Fig 2. FixedSys

Another “System” Font, FixedSys looks similar to System, but is different in a few ways. This font, shown in Fig. 2, differs so slightly from System; In fact, I can’t even see the differences, now. I did notice a change when I switched between System and FixedSys in the editor, though. Largely, whether one chooses System or FixedSys makes no difference; there are other, better fonts to choose from on any modern system.

Courier

Fig 3. Courier Font

Courier was another popular font at the time for programming, and other text-oriented tasks. Courier is basically the template “Typewriter” font. This brings the advantage (for most programming fonts) that it is monospaced. Typically, Courier is a “fixed” font. What this means, is that it isn’t scalable. This has good points and bad points; a good thing about this is that every font size is designed by hand; but the downside is, because of that there are usually fewer sizes to choose from. One issue with Courier is that the 0 (zero) and the O are quite similar, differing only in that the O is slightly thicker than the 0 (or the 0 is thinner than the O, depending on your perspective) This can make deciphering source code slightly more difficult. As does the similarities between the 1 (one) and l (lower case l); the number has a mere 3 pixels added on to what the l has! In an emergency, this font will do in a pinch, but I think it’s hour of glory has passed.

Courier New

Fig 3: Courier New

At some point, a newer, TrueType Courier font was created; being a TrueType font meant that the font could be resized to any size at all, on the fly. Engineers, however, were stuck on the name. A crack team of highly skilled engineers,  literature professors, and English majors were assembled, and they worked, tirelessly, for weeks trying to think of a name that says both “Courier”, and “New”. Eventually, they made a breakthrough; the name for this new font? Courier New, as depicted above in Fig 3.

Courier New was the staple font for basic text editors and Programming tools on Windows for years. It carries over a lot of the flaws of it’s predecessor, such as having easily confused 0′s and zeroes. They even made the 1 (one) and  lower-case L situation more difficult by making the net difference between them a single pixel. Overall, the font was nothing more than a true-typed version of it’s predecessor, which in and of itself was useful, since it allowed for using any size you could imagine. A contender appeared about the time of Windows 2000, This font, designed for the console, also makes a good Programming font, because it meets all the same requirements; Lucida Console.

 Lucida Console

Fig 4:Lucida Console

Lucida Console was born from the marriage between a Typewriter and an insect called the 7-year Lucida, which every seven years emerges from it’s burrow and showers random passerby with luck it stored in it’s cocoon. Lucida Console was made fun of often in the schoolyard, being forced to play with fonts like Comic Sans. The font isn’t terrible, but, it makes the worst mistake possible for a programming font (which debatably it isn’t to begin with, judging from it’s name) this is that it makes the 0 (zero) and capital O look identical. 1 and lower-case l still look different, thankfully, but having O and zero looking the same for a programming font is sort of like running to a halloween party without a costume and then saying that you are dressed as Steve Ballmer when you notice how much you had sweat on the way there. That is, it doesn’t matter how cool you are or look otherwise, you are still sweaty and possibly sticky and are therefore in the eyes of other guests best avoided.

Consolas

Fig. 5:Consolas

With the release of Vista, Microsoft got MonoType to re-envision many fonts; Consolas is the monospaced font (out of many fonts) that resulted from this. Basically it is designed to replace Courier New. Additionally, Consolas is better tuned to take advantage of ClearType. Also, some of the mistakes of Courier New were resolved; the zero is now clearly a zero, signified with a slash. the one and lowercase-l are still a tad similar, but Braces ({}) are a  bit more clear, as well. All around, probably my favourite programming font.

 Inconsolata

Fig. 6:Inconsolata

Unfortunately, Consolas comes with Windows Vista; you can install it on XP, but since it is tuned for ClearType it doesn’t always look quite right on Linux. Thankfully, there is an alternative for Linux, called Inconsolata . However, the problem is that Inconsolata appears to be tuned for *nix font smoothing, and looks a bit funky on Windows (even with cleartype off), as you can see in Fig 6. Obviously this isn’t so bad since for the most part Inconsolata is an attempt to bring Consolas to the Linux desktop anyway.

Because, from my experience, you can’t seem to get Inconsolata working properly on Windows (I’m probably doing something wrong, though) The picture does not do it justice; for all intents and purposes, it is pretty much the same thing as Consolas. If you program on a Linux/BSD machine in a graphical environment, I would recommend this font highly.

Proggy Fonts

Fig 7: Proggy Clean

Inconsolata is a free font; It is, however, hardly the only one of it’s kind. Dozens upon dozens of free fonts are available, for any purpose, including writing source code. Some fonts go that extra step and are explicitly designed to be used for editing source code. One such font in that category are the Proggy Fonts . The Proggy fonts come in several varieties; but they all hold to one tenet: to be as readable as possible at small sizes. This is the sort of idea I can agree with! Just look at Fig 7. gorgeous… nice, clean lines… a bit small though, if you are using a high-resolution. I’ve set my text editors to use this font.

Anonymous

Fig 8: Anonymous

Anonymous is an interesting font, mostly because it’s name is so silly. For me it seems like a thinner, monospaced version of Helvetica Or Arial; but, it does use serifs on a handful  of letters, such as Z’s, lower case L and 1. Anonymous crosses the zeroes, as well; making it easy to distinguish zeroes and the letter O. The slash extends outside the character itself, making it sort of look like a pictographic depiction of Uranus. Over all, another excellent font worth considering.

Envy Code R

Envy Code R

Envy Code R is another excellent programming font. The zeroes are slashed with a line that is more horizontal then usual, and the lowercase-L’s, ones, and I’s are all easily distinguished from one another. Another advantage is that the font scales rather well both to small sizes as well as large ones. The braces,brackets, and greater than and less than signs are all centered horizontally as well as vertically within the character box, which can be desirable. Like many of the other listed fonts, it appears to have pretty good support for unicode, as well.

There are many other fonts- I may make revisions and/or post new entries for them as I collect them together and  get appropriate screenshots.

Three common criticisms of MLP:FIM are that it is &#8220;girly&#8221;, &#8220;gay&#8221; and/or &#8220;childish&#8221;. Here is my rebuttal to these three perceptions. &nbsp; girly Well, there certainly isn&#8217;t a hard argument...

Three common criticisms of MLP:FIM are that it is “girly”, “gay” and/or “childish”. Here is my rebuttal to these three perceptions.

girly

Well, there certainly isn’t a hard argument one can make against it- after all, it’s not filled with macho robots or explosions or superheroes with superpowers. Well, I guess it sort of has the last one but that is something of a stretch. For the most part, all the “girly” ness can easily be attributed to corporate meddling; after all, they weren’t trying to make a gender-neutral television show, they were targeting a specific market at the time to try to sell their wares. The difference, I think, between the earlier version and the new version (which I base on assumptions about the first version from the 80′s because there is no way in hell I’m going to be watching those, low expectations or otherwise) will likely be that this newer version basically tries to skin the limits of the limitations they put on, and some bits easily slip under the radar; whereas the earlier ones probably didn’t need limitations set at all and they (the producers/animators/etc) went to create a show designed specifically for selling the toys, possibly with very little pride in their work. Now, naturally, it’s not for everybody. The ponies themselves are usually coloured in various hues such as purple, pink, and pastels that are often associated with the female gender. A better question is why that is the case, but I digress. They are however, animated fucking beautifully; the realistic animation of their manes during movement left me flabberghasted that the bloody thing was done in flash. Having experienced the creation of flash videos and realizing just how much work it is to add some minute, and innocuous details made me feel that there was a lot of pride on the part of the creators; after all, they could have easily gotten away with just moving the symbol up and down, say, when Rainbow dash or another pegasus pony is hovering, but they took the time, in each instance, the animate their manes and tail reacting to their oscillation; same with walking, running, moving their head. I can still watch it now and notice such little nuances and am still blown away by the expertise that went into it. Yes, there are some pithy bits like the letters at the end and a few tidbits here and there, but personally I like the contrast that sort of thing can provide with my other favourite shows, compare, for example, Charles Lister from Red Dwarf With Twilight Sparkle.

gay

Freddie Mercury was a Homosexual. That doesn’t mean Queen’s music isn’t fucking awesome, though. Well, unless you are a homophobe, I suppose. But really, I’m not really sure what this could possibly mean. I think maybe people just like the alliterative with girly so plop this in there as well with no real basis.

childish

Now, I will contend that you MAY have something of a point here, given that the show is, obviously, intended for that demographic. But I can’t help but wonder, personally, why they would pay such close attention to little details like the manes/tails swaying in response to movement/wind/etc and so forth, when clearly their “target demographic” isn’t going to nitpick that type of thing. Again, they take pride in their work, and this extends to the writers, who try to make things appeal to nearly any audience. In particular the various puns that wouldn’t be “got” by most in the “childish “bracket, such as the “nightmare moon”/”mare in the moon” which works not only because mare is the name for a female horse but also because mare is the singular latin word for “sea” and is used to describe the patches, or “maria” of plains on the moon. Hell I didn’t even get the equine->Equestria reference at all until a few days ago. I also rather liked the exploration of the ideas of Critical Thinking in the “Bridle Gossip” episode, even if they sort of took a backwards step in that regard with “Feeling Pinkie Keen”, which is my least favourite episode, Aesop-wise. Have I personally learned anything from it? Well, aside from the fact that book titles with long, alliterative and possibly redundant names are kind of funny, no. But compared to the cartoons I would watch as a kid, I feel this one is better done. Even if the theme song isn’t as catchy as Duck Tales, it makes up for it by not being STUCK IN YOUR HEAD AT THE WORST TIMES. Like, say you are at the altar and the minister says “And do you, XXX take this woman to be your lawfully wedded wife”, would you rather accidentally blurt out “DUCK TALES WOOHOO” or, “I used to wonder what love could be, until you shared it’s magic with me” etc. I mean, see, the second one might actually pass for a vow. IT COULD SAVE YOUR MARRIAGE.