Home Page
Misc > Languages and Libraries
Misc > Languages and Libraries

Warning: you do not have javascript enabled. This WILL cause layout glitches.

Languages and Libraries
Contains a list of all of my commonly used languages and libraries.

ASM C C++ C# VB4/VB6 VB.NET VBA VBScript JavaScript Java Flash (ActionScript) PHP Perl Python GoLang (Google’s Go) QBasic
Other language information:
Interpreted Languages XML and String Parsing Markup Languages (HTML, CSS, XML, etc)
  • ASM (x86 Assembly): This is the lowest level [low level] (closest to computer machine code) human readable computer language that exists.  The code that you write is the actual instructions (called opcodes) given to the CPU.  When writing in assembly, you only have a few intermediate ‘variables’ to work with, called registers, and a stack that you can push and pop variables from.  You can also only write one very simple line of code at a time, so things (like math functions) aren’t easily readable.

    Click here to toggle more information
    For example:
    would be written as
    ADD a,b//a=a+b
    ADD c,d//c=c+d
    IDIV c//a=a/c *
    *There are many caveats to assembly instructions, like only the A variable can be used as the dividend in division.

    This makes assembly a less than optimal language to use for programming unless you are coding for speed, as higher level [high level] languages can never be truly as fast or small as properly hand coded assembly.
    Assembly has one more major drawback, in that it doesn’t ‘scale’ with new technology.  In this, I mean that all processors are faster at certain things, and slower at others, so output varies depending on which type of CPU a higher level [high level] piece of code is compiled for.  For example, on older CPUs, the shift register (which multiples numbers by powers of 2) was extremely fast, unlike the slow ‘multiplier’ command, so it was faster to compile
    x*9 as x*8+x (8 is 2^3)
    for older CPUs as
    MOV b,a//b=a
    SHL b,3//b=b*2^3
    ADD a,b
    instead of
    IMUL x,9

    Then there are even more tricks beyond this, for example
    x*7 = x+x*2+x*4
    would be compiled for older CPUs as
    MOV b,a//b=a
    ADD b,b//b=b+b - b=(a*2)
    ADD a,b//a=a+b - a=(a*3)
    ADD b,b//b=b+b - b=(a*4)
    ADD a,b//a=a+b - a=(a*7)

    One of my favorite assembly tricks is variable swapping.  I’m not going into the math behind this, but it’s a neat trick.
    Instead of using a temporary variable to swap 2 variables (a and b) like....
    MOV c,a
    MOV a,b
    MOV b,c
    You just xor them back and forth
    XOR a,b
    XOR b,a
    XOR a,b

    Long story short.  Assembly is only for uber programming geeks like me that like to get down in the dirt and hard code things for speed.

    For compiling, to put things in simplified manner, each assembly code (including type of following variables) is really just an 8 or 16 bit value known by the CPU, and then accessed variables come after it.
    (These examples might not be entirely accurate.)
    For example, ADD a,8 would output directly to the CPU as
    ADD a,imd88
    and ADD b,a would output directly to the CPU as
    ADD V,Vebxeaxpadding

    The Intel assembly software developer’s manuals are freely available online. They detail all one would need to know to program in assembly, and the basics of CPUs and their design. They are excellent references.
    You can download the older digital copies I acquired in early 2004 here: Too bad Intel will no longer ship out hard copies of these books for free. I ordered one of, if not the very last, sets of these books right before Intel discontinued the free online offer ^_^;.
  • C: A simple name for the simple yet powerful language.  C is the predecessor to C++, and is the next closest language to the CPU.  It is my language of choice (well.. C99 is... see the more info section in C++ for more of an explanation) as it is super fast and efficient, robust, powerful, and customizable.  C lets you control ever aspect of your code to precise standards, and you know exactly how it’s going to compile and interact with the CPU. I sometimes mark programs as C that are technically C++. This just means it’s C99 and doesn’t include higher level C++ members like templating and classes (though it may also includes new/delete operators and cin/cout, which really just translate into alloc/free & printf/fread).
  • C++: The child of C, created/developed by Bjarne Stroustrup, has many advantages and disadvantages over C.  It adds higher level [high level] functionality to the language which, if not utilized properly, can seriously impact programming performance, in not only speed, but maintainability and other aspects.

    All C/C++ releases are (currently) formatted for and compiled in Visual C++ 6.0 (MSVC6), which has 4 spaces per tab.
    If running Visual Studio 6.0, don’t forget to install the Service packs in the following order: Service Pack 5, Service Pack 6, [SP6 to PP patch], Processor Pack
    I also recommend Visual Assist X for a nicer UI experience.

    Click here to toggle more information
    Many additions included in C++ also including in C99 that I utilize are:
    • inline functions
    • Variable declaration anywhere within functions
    • “bool” type
    • one line comments with “//”
    • improved support for IEEE floating point
    C99 also has variadic macros, which I’ve always wished C++ did :-\.

    I use classes whenever appropriate, very often with many inline functions for its simpler operations.
    But it’s when you start getting into polymorphism, inheritance, and virtual functions when things start getting... messy, and no longer very optimized.  Even normal C++ classes hide things from the user.  The “thiscall” class function calls basically just pass the pointer to the class structure as the first variable, which is why you can’t take function pointers of class functions, just “Pointer to member” (.* ->*) operators for something like it.
  • C#: See VB.NET. The “Predecessor” to C# is C++, though there are a lot more differences between the 2 than there are between VB6 and VB.NET.
  • VB4/VB6: Good ’ol visual basic.  It has “basic” in its name for a reason.  It’s not meant for true programmers doing real programs.  It has the ease of use, but not the flexibility or speed.  I still find it useful every now and then to throw together quick GUI apps when I don’t feel like dealing with C.  You can still do anything in it that you can do in other languages; just not as elegantly.  It also has the major drop in speed, as any interpreted languages do.

    You will need the VB language runtimes to run visual basic programs.
  • VB.NET: Like all .NET languages, VB.NET is pretty much the same as its predecessors (in this case, Visual Basic) by look and feel alone.  The only major differences are the available libraries, which of course are now all the .NET libraries, and that they compile down into the CLR (Common Language Runtime) byte code, meaning .NET is interpreted, so all the .NET languages are interchangeable and play well together.

    All .NET applications require the .NET framework be installed on your computer.  These are provided as automatic updates for all modern Windows operating systems, so you probably have them.
  • VBA: VBA is simply VB for Microsoft [Office] Applications.  It really doesn’t different from actual visual basic much, if at all.
  • VBScript: A web browser ‘scripting’ language like JavaScript.  It has pretty much fallen out of use due to its proprietary reliance on Internet Explorer.  I have only found use for it in interacting with some ActiveX Objects, like Flash.
  • JavaScript: Another web browser ‘scripting’ language that has also branched off to use in other applications, like use in Adobe PDF files.  It is the primary method of client side interactive development in web pages with the DOM (Document Object Model).  You pretty much can’t do professional web pages these days with out at least a little JavaScripting.
  • Java: Originally developed by Sun Microsystems, and recently made open source, very quickly caught on as a primary computer development language after its conception.  It is an interpreted language and rather slow, even compared against .NET.  I personally hate JAVA for multiple reasons including its sluggishness due to its less than optimal garbage collection, the fact that it only encodes and does not compile to byte code, and that many colleges teach only it so students become reliant on it and completely worthless.

    The one thing I do like about Java is that it is can be used to implement the most powerful web applets, as it is more robust than Flash.  But even this comes at a price, in that most people do not have Java installed to run in their web pages, nor do they have reason too.
  • Flash (ActionScript): Flash is primarily used as a true multimedia platform for web pages and has quickly caught up to JavaScript in use, and will someday probably bypass it.  It can also be used, through the Flash Projector, as a semi-normal application.  Flash uses ActionScript as its internal programming language, which is interpreted.  The only problems with Flash, and the reasons it is not more widely utilized, are its proprietary nature, and that it does not come installed by default on most web browsers.  Fortunately, the latter problem became mute around the advent of YouTube, which introduced web video to the masses.  Flash is a non-open format owned by Adobe (it was bought out from Macromedia a number of years ago), though it has been cracked, and like all web resource, can be decompiled to its original source (Temporarily down).  Unfortunately, Flash is also very restrictive in some areas, for security reasons, in which Java is more suited as a web applet.
  • PHP: PHP is, in my opinion, the most suited language for standard server side web page programming.  It is a successor to Perl, and has a very very useful base library set, is very simplistic and quick as a scripting language, and is easy to debug.

    Click here to toggle more information
    Its downsides are:
    • It is interpreted
    • Separate instances are ran for each web page load, so can be a bit tricky remembering data between sessions
    • It has no garbage collection.  Its only real memory management is that local variables are deleted on function exit.  Though this actually isn’t necessarily a bad thing, as memory management is time consuming, and all memory is dropped immediately on the end of the run instance.  This only really becomes a problem when you try to use PHP for large memory processes that take a long time to run (like mass email sends.)
  • Perl: Perl is the predecessor of many languages, including PHP.  It is interpreted, and can be run from either a compiled byte code format, or straight from its original source.  This makes it very useful for enterprise applications that do not rely on speed and may need to be worked on and edited far into the future by many people. Perl has a VERY large repository of ‘official’ libraries to help speed along development. It’s great for quickly scripting together projects that mainly rely on text manipulation.
  • Python: Python is a bit different in that it is an interpreted language, but it is not dynamic in nature (no eval statement), and it is [dynamically] typed. It’s great for large projects that aren’t time critical due to its quickness in developing and typed nature making it easier to debug. See Python Pros and Cons for more information.
  • GoLang (Google’s Go): This language fills a nice niche between compiled and interpreted languages. While it is compiled, so code runs very fast, it has support for a lot of features needed in a modern language that C++ just does not fill. This includes:
    • Strong and natural string and Unicode support
    • Strong concurrency and threading features
    • Garbage collection (which may or may not be a hindrance depending on your goals)
    The language also forces the programmer to adhere to a very strict set of syntax [and other] rules, which allows programs to compile SUPER fast, but also removes a ton of flexibility. Quite frankly, my experiences with the language so far have been very jaded due to this strictness.
  • QBasic: Also known as QuickBasic, this was the first language I ever wrote in, and is very, very, very old.  It is the successor of BASIC, whose main difference was that you had to write line numbers in front of every statement.  QBasic programs are ran straight from their code in the editor environment (straight off the Win98 CD), though a pre-internet-elusive compiler does exist.
  • Direct3D (D3D): Microsoft’s 3D library and interface to GPUs (Graphical Processing Units). Only available for Windows. This is one of the parts of DirectX.

    Direct3D requires that you have DirectX installed.
  • OpenGL: The open source 3D library and interface to GPUs.
  • GPU ASM: Assembly language for GPUs.  These are the low level way to right 3D shaders for the pixel, vertex, or geometry pipelines.
  • MySQL: The most widely utilized open source database solution (recently bought out by Sun). SQL is a [scripted] computer language used for querying information from databases.
  • MSSQL: Microsoft’s implementation of SQL... it’s rather quirky.
Other language information
  • Interpreted Languages:
    This means that the languages do not compile down to native machine code (executables).
    The problem with this is that each line of code has to be interpreted before it is ran which is extra overhead, and string parsing does not come cheap.

    When you ‘compile’ them, they either:
    • A) Compile down to a “byte code” format which is like a high level assembly language.  Examples of this are .NET, and Flash.  This method is slightly faster than the next method because it requires less string parsing.
    • B) Exact original code is kept and just encoded (made to look binary, but easily reversible back to exact original code).  Examples of this are Java, and if I recall correctly, VB.
    And then of course you have the languages that don’t even pretend to compile like JavaScript, and those which you don’t have to compile to run like Perl, and PHP (though these two both compile into a bytecode when you run them.)

    I have read articles before that say in the long run, interpreted languages will outlast compiled languages because they will keep improving the virtual engines and old code will run better with less security problems without needing recompiles, but I highly doubt this.  The only way this could come true is if hardware is made specifically to run the bytecode as actual opcodes
  • XML and String Parsing:
    While XML has its uses, I feel it is by far an overused format.  String parsing has never been fast, and due to the nature of it, can never really be as fast as a binary type file format.  Sure, hardware implemented to really speed it up and even make parsing it as fast as INI files is possible, but such hardware will probably continue to be considered overkill for a long time... until the drone XML advocates (ie Microsoft) take over the world and force it upon us, its willing slaves.

    Now, don’t get me wrong, I admit XML can be great in some circumstances.  In environments where the XML will need to be changed by hand very often, it’s great.  But in my opinion, that case doesn’t come up very often outside strict development environments.  Is it really that hard to make interfaces to manipulate binary file formats?  Well... ok, sometimes maybe :-p, but it would still end up being much less confusing in those cases to have a real data manipulation interface than trying to browse through multitudes of lines of XML.

    What really turned me off of XML (well, I never did like it from first mention, but what gave me a valid opinion against it) is products like adobe that take tens to hundreds of times longer to load than they should due to layout config files being made in XML type files, when they could easily be compiled since no one really ever edits them anyways.  Or at least have the option to have them as either binary or text formatted.

    It takes (theoretically) double the time to work with zero terminated strings with an unknown length due to having to count the length before working with them.  It’s even worse when you don’t know how the string will end in a text formatted type document because then you can’t use CPU optimized string commands.

    The windows registry was supposed to take care of this for simpler circumstances, but who wants to bloat the already bloated registry?   Especially if you have thousands to millions of entries needed in your data.
  • Markup Languages (HTML, CSS, XML, etc):
    Markup languages like the ones noted in the title are not programming or scripting languages at all. They are a way of organizing objects with values and data. For example, this is a section of HTML that displays “Google”:
    <b><a href=http://www.google.com>Google</a></b>
    This contains a link (object type is named “a”) that points to Google via the “href” value, and its data/text “Google” is inside of it. It is inside a bold (“b”) object.