27 Oct 2016 @ 12:39 PM 

This is part of a series of posts covering new C# 6 features. Currently there are posts covering the following:
String Interpolation
Expression-bodied Members
Improved Overload resolution
The Null Conditional operator
Auto-Property Initializers

Yet another new feature introduced into C# 6 are a feature called Dictionary Initializers. These are another “syntax sugar” feature that shortens code and makes it more readable- or, arguably, less readable if you aren’t familiar with the feature.

Let’s say we have a Dictionary of countries, indexed by an abbreviation. We might create it like so:

This is the standard approach to initializing dictionaries as used in previous versions, at least, when you want to initialize them at compile time. C#6 adds “dictionary initializers” which attempt to simplify this:

Here we see what is effectively a series of assignments to the standard this[] operator. It’s usually called a Dictionary Initializer, but realistically it can be used to initialize any class that has a indexed property like this. For example, it can be used to construct “sparse” lists which have many empty entries without a bunch of commas:

The “Dictionary Initializer” which seems more aptly referred to as the Indexing initializer, is a very useful and delicious syntax sugar that can help make code easier to understand and read.

Posted By: BC_Programming
Last Edit: 27 Oct 2016 @ 12:40 PM

EmailPermalinkComments (0)
Tags: , ,
Categories: .NET, C#, Programming
 15 Aug 2015 @ 4:18 PM 

Windows 10 has been out for a few weeks now. I’ve upgraded one of my backup computers from 8.1 to Windows 10 (the Build I discussed a while back).

I’ve tried to like it. Really. I have. But I don’t, and I don’t see myself switching my main systems any time soon. Most of the new features I don’t like, and many of those new features that I don’t like cannot be shut off very easily. Others are QOL impacts. Not being able to customize my Title bar colour and severely removing all customization options, for example, I cannot get behind. I am not a fan of the Start Menu, nor do I like how they changed the start screen to mimick the new Start menu. I understand why these changes were made- primarily due to all the Windows 8 naysayers- but that doesn’t mean I need to like them.

Windows 10 also introduces the new Universal App Framework. This is designed to allow the creation of programs that run across Windows platforms. “Universal Windows Application” referring to the application being able to run on any system that is running Windows 10.

If I said “I really love the Windows 8 Modern UI design and Application design” I would be lying. Because I don’t. This is likely because I dislike Mobile apps in general and having that style of application not only brought to the desktop but bringing along the same type of limitations I find distasteful. I tried to create a quick Win8 style program based on one of our existing winforms programs but hit a brick wall because I would have had to extract all of our libraries and turn it into a web service, then have it running in the background of the program itself. I wasn’t able to find a way to say “I want a Windows 8 style with XAML, but I want to be able to have the same access as a desktop program”. It appears that this may have been rectified with the Windows 10 framework, as it is possible to target a Universal app and make it, errm- not universal- by setting it to be a Desktop Application. I hope- though have as of yet been unable to determine if that is possible and it is looking more and more like it isn’t. This makes my use case- to provide a Modern UI ‘App’ that makes use of my company’s established .NET Class Libraries – impossible. This is because for security reasons you cannot reference standard .NET Assemblies that are not in the GAC. I was thinking they might work if they are signed in some fashion, but I wasn’t able to find anything that would indicate that is the case.

the basic model, as I understand it, mimicks how typical Smartphone “apps” work. Typically they have restricted local access, and will access remote web services in order to perform more advanced features. This is fairly sensible since most smartphone apps are based off of web services. Of course, the issue is that this means porting any libraries that use those sorts of features to portable libraries which will access a web service for the required task. (For a desktop program, I imagine you could have the service running locally)

I’m more partial to desktop development. Heck right now, my work involves Windows Forms (beats the mainframe terminal systems the software replaces!) and even moving to WPF would be a significant engineering effort, so I keep my work with WPF and new Modern UI applications ‘off-the-clock’.

Regardless of my feelings regarding smartphone ‘apps’ or how it seems desktop has been taking a backseat or even being replaced (it’s not, it’s just not headline worthy), Microsoft has continued to provide excellent SDKs and Developer tools and documentation, and is always working to improve both. And even if there is a focus on the Universal Framework and Universal Applications, their current development tools still provide for the creation of Windows Forms applications, allowing the use of the latest C# features for those who might not have the luxury of simply jumping to new frameworks and technologies willy-nilly.

For those interested in keeping up to date who also have the luxury of time to do so (sigh!) The new Windows development Tools are available for free. One can also read about What’s New within the Windows development ecosystem with Windows 10, And there are also Online courses regarding Windows 10 at the Microsoft Virtual Academy, as well as videos and tutorials on Channel9.

Posted By: BC_Programming
Last Edit: 30 Dec 2015 @ 08:01 PM

EmailPermalinkComments (0)
 30 May 2015 @ 9:42 PM 

This is part of a series of posts covering new C# 6 features. Currently there are posts covering the following:
String Interpolation
Expression-bodied Members
Improved Overload resolution
The Null Conditional operator
Auto-Property Initializers

C#, like many programming languages, is quite incredible. One of the biggest reasons I think C# is amazing is not so much what it is today, which is still quite spectacular- but because of what it could be. C# is constantly being improved, revised, and new versions come out fairly frequently. this is not without it’s downsides, the primary one is that in order to develop and maintain something you will quickly find that your work is with “legacy” libraries and language versions.

I was originally planning to go over each new C# feature in a single blog post, but with that sort of format I didn’t think I really had much unique information to add on the topic, as we can easily find a lot of great posts and articles that cover the new C# features. Instead, I’ve opted to look into each one more thoroughly.

Just what is String Interpolation, anyway?

The idea of String Interpolation is actually somewhat foreign to most statically-typed languages. Instead, it is found primarily in dynamically typed languages such as Perl. the effective idea is straightforward- rather than strings being treated as is, they can be interpolated by the interpreter, compiler, or at run-time, and changed in some fashion. Typically, this is done by indicating, for example, replacement text or information that get’s interpolated as part of parsing the string or during run-time. The best way is with an Example. We’ll start with a Perl example:

if we run this code, we get the output:

The String Interpolation feature of Perl works automatically, and in that environment we can put any in-scope variable name in the string itself directly and have perl interpolate the string and replace it with the current value of that variable at the time of interpolation.

When it comes to C#, The concepts are similar. in general, the best way to think of it in a C# context is as a “shortcut” for the use of String.Format(). for example, an analogous C# program like look like this:

this is, of course, without String interpolation. WriteLine supports the “String.Format” syntax, which is similar in many ways to the C printf() function and it’s equivalents. With C# 6’s String interpolation, we can make it a bit easier to follow:

This makes it a bit easier to follow; you can see here that the interpolated parts of the string reference the names of in-scope variables. This is a better approach- generally- than the String.Format() style which uses braced numeric indices to reference the additional parameters provided to the function.

Somewhat disappointingly, this is typically about as far as many of the articles and blog posts covering the feature tend to go. this makes it seem like a straight-up String.Format syntax sugar, but they tend to fail to truly show how many sugars you get from the feature in your C# cup. The contents of the interpolated parts of the string can actually be any expression- you aren’t merely limited to listing variable names, you can even insert function calls. Take this example:

This gives us:

This example interpolates two calls to the same method on the same instance. This shows us something else about string interpolation, which is that it appears elements are interpolated left to right (arguably, this is how we would tend to expect it). Since this function has a side-effect of incrementing (as the method name sort of gives away) a field variable, the second interpolation of the same method call returns a different result which is then reflected in the output. This is really still a String.Format syntax sugar, but the result tends to be a bit easier to follow. There is, arguably, one downside compared to String.Format, which is that you cannot store the format strings in a string variable or a resource. This is because, as mentioned, the feature is more or less syntax sugar for String.Format(), which means the actual interpolation really takes place at compile time- the resulting code has no “String Interpolation” as it is, and of course variable contents that are only available at run-time can’t be considered when compiling. This means that String.Format() will continue to be a valuable “ally” when it comes to variable replacement within resource-defined strings.

Come to think of it, one could almost make an argument that the String Interpolation feature is encouraging poor style, since String interpolation is not as easy to move into string resources as straightforward String.Format() calls. While this may be true, I think any feature can be misused and possible misapplications or poor style that may be encouraged by the overuse of a feature is not a reason to not provide that feature. You cannot fix bad programming with language features (or lack thereof) and I personally feel that language features should merely be considered tools to be used by the programmer themselves, not tools to enforce the preferred programming styles of those providing the toolbox.

Posted By: BC_Programming
Last Edit: 11 Jul 2015 @ 06:11 PM

EmailPermalinkComments (0)
 05 May 2015 @ 10:53 AM 

After my recent minor troubles with web hosting and domain name weirdness,I decided to look into possible ways to branch out, or improve the site. While discussing the issue, I was reminded of Azure.

Microsoft Azure

Microsoft Azure is essentially Microsoft’s cloud computing service and platform. I must confess that I knew very little about it (not much more than I knew about most web technologies, to be honest) but as I had some Azure credit I decided I should at least make use of them to try to learn something. If there is one thing I haven’t been doing quite enough of lately, it’s branching out and learning new things. It’s one of those things that it seems like even with all the time in the world, keeping up with it will be a struggle. At any rate, I dove in.

Setup was surprisingly straightforward. I was quickly guided through a series of steps and able to setup a Windows Server VM. My understanding, so far, of the service is that you can create a VM which then runs endpoints, cloud services, and web apps. Depending on how you configure it and how many of these you setup (as well as your chosen specs for the VM itself) you will use differing amounts of credits. Effectively, how much traffic you get will be the main determining factor.

My first hurdle came with the Azure SDK. After a few failed attempts, I decided it might be time for a reboot- just to make sure that wasn’t related. What do you know- it worked, and I was able to install the SDK. With that installed, I opened Visual Studio 2013 and was able to create a new ASP.NET project. I chose a basic Razor sample web application.

After this was setup, I was able to publish the project directly to Azure via a publish option shown in the lower pane view. “So far Visual Studio and Azure had certainly worked for me” I thought, as I pointed my browser at the new website.

Server timeout, was the response to my optimism. After some head-scratching and googling the problem, I discovered I had missed an important step- I had not added a new “endpoint” to Azure. I needed to add an endpoint for Port 80, to allow HTTP traffic. After doing so, my example website worked like a charm. of course I still have no idea how it works, but now I’ve got a very reliable and easy-to-use platform on which to play with some of the web-based capabilities of .NET. This could mean great things- if I’m able to get a grasp on web applications in C#, it may be worth it to create a new Azure subscription for the purpose of a web application for managing BASeCamp Downloads. My current “technique” is over 5 years old now and it’s built using old, crusty PHP code I wrote while learning PHP, and I’ve actually forgotten how a lot of it works- so if I can create something via C# I may be able to make something that is more powerful and may allow for better integration into my existing applications. At the very least, it would be interesting since I could create a Service-type program which sits in the background and can address requests from various Updaters and interact directly, rather than via HTTP; or the data could be piped via XML in some fashion, etc. The usage of Azure opens up these possibilities and in ways that encourage experimentation.

I’d include a link to the Azure instance, but it really is effectively a fiddled-with version of the default template. I have a lot of learning (and catching up, arguably) to do to get up to date with many of the new design methodologies that are put into play. It is much different from the “seat of your pants” style that PHP seems to encourage. I think the trick is to think of something interesting and that I might find useful to create via an Azure instance, and then work towards that goal, learning as I go. It worked for BASeBlock, after all.

Posted By: BC_Programming
Last Edit: 05 May 2015 @ 10:53 AM

EmailPermalinkComments (0)
Tags: , , , ,
Categories: .NET, Azure
 03 Apr 2015 @ 3:26 AM 

Somehow I’ve managed to never write about my Debug log class, looking through my post history.

It’s a versatile Debug Logging class that effectively hooks into and allows tracing of Trace.Write and Debug.Write method call output. I use it to redirect all Debug.Print() output to a text file for later examination. Some of my original considerations included being easy to use and add to existing software programs, as well as being able to do it’s job with as little interaction as possible. I’ve been able to use this successfully in it’s original program (BASeBlock) as well as inserting and using the class for Debug log functionality in software created and maintained as part of my Job, and it has worked wonderfully.

Example usage is straightforward- you enable logging by simply accessing the “EnableLogging” property; typically I set it to true for obvious reasons. The Static initializer of the class sets everything up from there:

And BAM! We’ve got a fully functional debug log- after the debug logs become a week old, they get purged, too! How is that for convenience?

Posted By: BC_Programming
Last Edit: 03 Apr 2015 @ 03:27 AM

EmailPermalinkComments (0)
Tags: ,
Categories: .NET, C#, Programming
 30 Mar 2015 @ 1:12 AM 

We have had a lot of different options for creating Zip Files in .NET Applications for some time. .NET 4.5 has added built-in framework-based support for Zip files, which is a very valuable tool. The absence of built-in ZIP support meant there have been several useful libraries that provided that capability. In this post I will be comparing three such alternatives- DotNetZip, SharpZipLib, and the built-in .NET Framework 4.5 implementation.

In particular I am focusing on ease of use- how much code does it take to create a zip file? Libraries that provide these capabilities often fall into categories- libraries which make something possible, and libraries which make it easy.

First, we should look at the “testing framework” that will be used. The idea is straightforward- we want to simply have each one zip up a given folder to a given zip file, with different implementations. an Interface is the obvious choice:

A single-method interface. We’ll create an implementation for each of the selected libraries implementations, then test each one. Though performance is not the primary focus, we’ll go ahead and try to implement a basic average/total framework over 100 runs:

Nothing fancy- just as described above. A short helper will ensure the folder exists and the target zip does not when running one of the instances, simply so we don’t need to implement it in every single one.


DotNetZip is the one I was most familiar with before this particular experiment, having used it in a few projects.

Incredibly straightforward, overall- create a new Zip File, add the directory to it, and save the zipfile.


I don’t remember using SharpZipLib but I do remember discounting it over DotNetZip for some reason when I was originally looking for a ZIP tool. I was reacquainted with my reasoning in the process of writing the implementation here, which should be fairly obvious:

This is just plain silly- this I suppose falls into the category of a library that makes something possible but doesn’t make a big effort to make it easy, or leaves out higher-level capabilities. Effectively when using SharpZipLib you’ll need to deal with the insertion of each ZipEntry yourself, or create your own wrappers for it. The wrappers are not super difficult to make but if you already have a zip task you want to write simply that is more overhead that needs to be considered.

Framework 4.5’s System.IO.Compression

The Framework implementation is as I mentioned a great addition to the framework. It’s usage is also surprisingly easy:

If you include a reference to System.IO.Compression.FileSystems, you get access to some helper capabilities such as the ZipFile class, which I use here- the method is literally identical the interface method I defined myself.

I think the built-in .NET Version is the clear winner here, but DotNetZip is certainly a better alternative if using the 4.5 Framework has it’s other considerations. SharpZipLib is surprisingly unfluent and requires a lot of boilerplate to be used well, but it is an excellent low-level library for compression overall. Additionally, we have the performance considerations. After a single run, the program emitted the following results. I was testing with a reasonable set of files including a number of PNG images, text files, source code, and other data.

DotNetZip comes in first, with the Framework lagging just behind. SharpZipLib executed a full second longer with each execution, which may be due to the lack of optimization within the program itself (Debug mode) since more of the processing was actually taking place within the code in the project. Unfortunately, this turned out to not be the case- setting the configuration to release did not significantly improve the performance of the SharpZipLib implementation, though it may simply be a less-than-optimal implementation. However if so, that does raise the further point that having to write your own boilerplate means you may not write the most effective and optimal boilerplate for a given task.

Posted By: BC_Programming
Last Edit: 30 Mar 2015 @ 06:10 AM

EmailPermalinkComments (0)
Tags: ,
Categories: .NET, C#, Programming
 09 Dec 2014 @ 10:05 PM 

I found this to be an interesting discovery. I always somewhat expected each .NET language to work in a similar way with regards to things such as field initialization, but as it turns out, C# and VB.NET work differently in this regard, and in both cases it is due to design decisions with the language themselves. To best show this, I created two equivalent class heirarchies in C# and VB.NET



Both are effective a base class with a non-default constructor which has a static field and a instance field, and a class derived from that class which implements a similar non-default constructor and sets a derived instance which along with a static field are both initialized at their declaration, then creates an instance of the derived type.

I breakpointed all statements in the program, and traced through each one. in C# the progress was:

  1. Derived Static field initialized
  2. Derived Instance field initialized
  3. Base Static Field Initialized
  4. Base Instance Field Initialized
  5. Base Constructor execution
  6. Derived Constructor Execution

In VB.NET, we have the following order:

  1. Derived Static Field Initialized
  2. Base Static Field Initialized
  3. Base Instance Field Initialized
  4. Base Constructor Execution
  5. Derived Instance Field Initialized
  6. Derived Constructor execution

This has interesting repercussions. for VB.NET the main repercussion is that if you call a virtual (Overridable) method from the base constructor, within that virtual method the instance fields will not be initialized, whereas, with C#, they will be. On the C# side, it is likely the reason that derived instance fields cannot be initialized by calling an instance method, because the initialization of instance fields occurs before the base class static and instance fields have been initialized, so the class state within that method would be difficult to predict. Arguably, it seems that Visual Basic .NET takes a more “You probably know what you are doing” approach, whereas C# is more careful and “safety” conscious.

Posted By: BC_Programming
Last Edit: 09 Dec 2014 @ 10:05 PM

EmailPermalinkComments (0)
Tags: , ,
Categories: Programming
 05 Mar 2014 @ 10:22 PM 

introspection into Types, Methods, and Parameters is a very useful feature for the creation of highly dynamic programs. One use for this ability is to allow generic methods to be highly expansive.

Take for example, a function that wants to read in an object, and initialize the properties and fields of that object to data stored elsewhere. Perhaps a database, or maybe a dictionary or some other data structure. At any rate, it wants to be able to instantiate and create an instance and populate that instance without actually knowing the specific type at compile time.

The first step to such a method would be to instantiate the class. The most straightforward way would be to acquire the parameterless constructor, and invoke it- the result will be the constructed object.

This approach does, however, have some undesirable curve-balls that can bite you. Observe in this example:

The result of running this program is the following output:

What is going on here? Why is the class instantiatable, but not the struct, even though they are exactly the same? Both can be instantiated using new SimpleClass() or new SimpleStruct() in the code- why does reflection claim things that don’t seem to make sense?

The reason appears to be partly because of how unreliably the constructor is called in certain circumstances by the CLR, as well as how defining a parameterless constructor in such a way pragmatically makes that struct “mutable”, which can cause issues when dealing with value-type assignment, (which copies the struct, rather than copying a reference to the struct). In order to stay as consistent as possible, the C# compiler does not emit a constructor for any value types and instead relies on the standard CLR struct initialization. As a result, you can’t define one yourself. Jon Skeet provides a far more in depth look at the underpinnings that are the cause of this particular result.

At any rate: the reason you don’t see a constructor when reflecting on a C# type is because C# doesn’t emit constructors on value types

Posted By: BC_Programming
Last Edit: 05 Mar 2014 @ 10:22 PM

EmailPermalinkComments (0)
Tags: , ,
Categories: .NET, C#, Software
 04 Feb 2014 @ 10:36 PM 

Handling and dealing with Errors can be tricky. When your program crashes you want to fix it as soon as possible. One of the most valuable pieces of information- when the Error is generated from a .NET Program- is the Exception type as well as the stack trace, which can be used to try to determine the cause of the problem.

More prudently, of course, it makes sense to also log data. My personal approach is to implement a relatively simple class that will write log files to the Application Data folder, and overwrite old logs. It is implemented as a TraceListener, and merely needs to be invoked to start capturing Debug output to a file. The advantage here is that the Debug statements are removed in a release build; the downside is that the Debug statements are removed from a release build. Using the Trace class instead of the Debug class for writing debug output will allow that trace output to be captured by the “DebugLog” class, listed below.

The debug logs captured can be exceedingly useful- a more full implementation of a Debug handler, or unhandled exception handler, could very well zip up some of those files and E-mail them to an appropriate Support address.

But what about Exceptions that occur that you don’t catch? Sometimes you simply don’t catch all your exceptions- and it’s reasonable, having a catch-all Exception handler can cause just as many unexpected issues as catching only those exceptions you know how to handle. Thankfully, all .NET Exceptions are actually logged to the Event Viewer.

A Application that was simply too exceptional for this world... hyuk hyuk.

A Application that was simply too exceptional for this world… hyuk hyuk.

The information is therefore available; but guiding a client or customer through the process of wandering through the Event Log is a bit much. So it makes perfect sense to let an Application do this job for you. Thankfully, .NET has a rich capability in terms of inspecting the Event Log. I Created a quick Application to demonstrate (Includes source code).

The principles exercised in the project could easily be used to create a zip or other archive filled with useful diagnostic information in the case of an unexpected crash; that zip could even be automatically E-mailed to support (as I mentioned above). With such a wealth of information it can help eliminate a lot of time-wasting back-and-forth trying to determine the cause of a problem. If nothing else, something like this Application would make finding the proper information slightly easier (with the appropriate tweaks to make the Stack Trace visible).

Posted By: BC_Programming
Last Edit: 04 Feb 2014 @ 10:36 PM

EmailPermalinkComments (0)
 14 Oct 2013 @ 12:21 AM 

This is a topic that I find recurring between myself and my non-programmer friends, as well as people providing freedback on some of the Open-Source repositories I contribute to and help maintain. Questions such as “what drives you” or “if you aren’t getting paid, why do you do it?” Sorts of questions.

My normal response is “Why do painters paint?”. The old standby. But I think it’s an interesting question too. The reasons that I like to develop, design, and implement software can be traced to the same things. I Enjoy programming for a multitude of reasons. It’s something I’ve found that I’m good at, and that I can continue to grow better at over time; there is no glass ceiling of skill that I will hit. Something about it makes it far more expressive than it would seem at first glance. There is more than one way to write a program to do a non-trivial task, and with experience and skill you are able to become familiar with both the language in question as well as how you use it; and you can carry over some of this skill and ability into everything you do.

There is something innately fulfilling about looking around and seeing people benefit from software you’ve written, regardless of what it is. Arguably depending on the software there is also responsibility for that software that you implicitly take on regardless of any “Terms of use” that remove such warranty. For example even though you are legally in the clear if a piece of software does something it shouldn’t or causes a problem for a user, you are still bound by the contract of not being a massive douchebag to at least try to help especially in terms of fixing the bug if not helping to recovery any lost time or data that the user lost.

Even in the most boring and otherwise dry Application, there is some consideration to be made for how maintainable the software is going to be. If you go into a large project and just code what you need by the seat of your pants you are just going to make more work for yourself in the long run; so you have to try to get an idea of the larger picture, and then focus on drawing out the details in each area so it flows smoothly; like the charcoal pre-painting step of an accomplished painter, you are able to see if this will work in the overall composition as per the software requirements. Additionally even in the most restrained set of requirements there are choices and decisions to be made by the programmer in terms of the actual make-up of the code and logic- eg, what will be represented by classes and how those classes will interoperate. A common quotation, (though I’ve forgotten the attribution) is, “The definition of Insanity is doing the same thing twice and expecting different results”. I guess you could say the definition of Art is getting two people to do the same thing and getting vastly different results.

This takes me to the almost separate topic of whether Software Development is an “art”. I’d say that it is in many ways- the aforementioned tongue-in-cheek definition being a good example of why this is. But at the same time, how is it “Computer Science” when it’s actually an Art? This is something that baffles onlookers to the subject- some Programmers feel they are artists. Others feel they are academics working in a professional Science.

The answer is simply that they are separate. For example, when you study light and colour and pigments in chemistry and science classes- that is science. It is when you apply that understanding as well as a understanding of how we [i]interpret[/i] colour that it becomes an art; and in terms of painting (or any graphical art) the “art” is more in terms of using the skill with the medium to give a message. When it comes to Programming, we have a bit of a different thing going on; I’d say that for Software Development you actually have to deal with two things- you need to deal with the Compiler/Interpreter/Computer that is compiling and running your code, but you also have to deal with the people who will read your code later on, including yourself. It becomes an “art” to balance the requirements of the program and try to come up with the most elegant, and easy to read Source code to describe an otherwise complex problem.

I imagine this is partly why I find it so fascinating. Another reason is that once I’ve written something well, and moved on- I can always both revisit that project or class to make improvements, or simply touch it up and post it here on my blog (which I’ve done for a few classes) which actually has another interesting sidebar in that those improvements I do make often come as a result of my actually opening that project or class to try to touch it up for a new blog post. In that way I build up a library of small libraries, and classes that I can use for a variety of common tasks, making complex requirements such as high-level automatic support for List View Sorting UI handling almost trivial. I think this sort of “art” helps the end-user because it means for example that the otherwise complex functionality, which now takes a single line to actually implement, basically needs a good reason to not exist. You cannot argue that it would take too much time to add a single line of code to add the implementation, and the class itself being reasonably well-tested is a sort of assurance of how well it will work.

That isn’t to say it’s always fun and games. TO be honest I’m actually a bit disappointed with how little work I’ve done- I mean I do have a good number of projects, but I feel I could have a lot more, and even then those projects I do have suffer from neglect because unfortunately there are only 24 hours in the day and I’ve decided against moving to Venus because I prefer to not have my skin boiled off and corroded by a real-life dutch oven planet, even if that would give me a day that is 100 times longer. And that joke had far too much setup and a delivery that makes me glad I didn’t pay shipping. Anyway- I don’t even remember when I last opened BASeBlock- and even then it was probably to see how I did something to try to adapt it for a work project; I would have to look back even further to see what the last time was that I actually opened it to try to get some work done on it. Another issue I’ve found for those projects recently is that now that I actually do this sort of thing for my actual work I find that- unlike my previous Jobs- At the end of the day I simply don’t want to see Visual Studio anymore. This is actually fine by me- it tells me that what I am doing is mentally engaging and I’m still learning.

This actually makes me understand some of the weird habits I’ve seen from career programmers. I’ve noticed for example that many career programmers that have hobby projects will make their hobby projects in another language from their work, which I’ve never entirely understood. But Now I can see- they want to distance those hobby projects from the work they do to make their living, if only in their own mind. Even using a separate IDE for the same language can sometimes make the difference. For some Java Work Projects I used Netbeans, but for my hobby programming in Java I used Eclipse (And now finally switched them to IntelliJ IDEA). The fact that you are in a different environment is a “cue” to your brain to do stuff your own way, I suppose.

That said, I still hope to eventually get back into developing Prehender. It’s fun to learn new stuff and even deal with OpenGL while still being able to rely on my skills with C#. And it would have the advantage of being a completely different playing field from anything else I do or have done.

Speaking of “Prehender” who’s name’s origin I’ve forgotten, but there was a reason for it- I ought to write a blog post on the gameplay ideas I had for that. It’s not revolutionary but it’s simple enough to be something I feel capable of even with my limited 3-D experience while still being something I think would be a playable and engaging game experience.

Posted By: BC_Programming
Last Edit: 14 Oct 2013 @ 12:21 AM

EmailPermalinkComments (0)
Tags: , , ,
Categories: .NET, C#, Programming

 Last 50 Posts
Change Theme...
  • Users » 41491
  • Posts/Pages » 347
  • Comments » 104
Change Theme...
  • VoidVoid « Default
  • LifeLife
  • EarthEarth
  • WindWind
  • WaterWater
  • FireFire
  • LightLight


    No Child Pages.

Windows optimization tips

    No Child Pages.

BC’s Todo List

    No Child Pages.