jarid_lawson's Feed - Programmer's Heaven

The required nod to the Hello World application – Part 3

Mon, 14 Mar 2011 11:31:06 -0700

So I inadvertently lied to you last time, because this post is a week late. I apologize, but I was in a wreck a little over a week ago. It was minor enough to not "be a thing", but I was still down all week last week.

So to begin today's lesson...The Imports Keyword
First, here is the code we're looking at:

Imports System
Namespace MyHelloWorldApplicationns
    Module MyHelloWorldModule
        Sub Main()
            Console.WriteLine("Hello World")
            Console.ReadLine()
        End Sub
    End Module
End Namespace

The Imports keyword is like an invitation to a party for a specific namespace. We use this keyword to gain access to specific classes within the namespace such as System.Console. Without this invitation, we would not be able to use the functions, or modify the attributes of any of the Console objects.

Now you may think that since a namespace can be both a parent and a child of other namespaces you can just call one namespace to access the entire namespace family tree. This however is not the case. Say for instance you want to use the Collections namespace in System as well as the System namespace. You must must use the following code:

Imports System
Imports System.Collections

Modules
Alas we will have to wait for a more detailed explanation than I'm about to give, because the material I'm reading is telling me we're going to hold off for now. You may be saying, "But you were a programmer before, why can't you answer what is truly a basic question?" That's simple, I knew how to make the code work, but I never bothered learning all of the specific names and subtle features for each segment of VB6. I taught myself in a very quick and dirty method, which is why I am being so detailed in my approach this time around. I want to fill in the holes in my knowledge. Stick with me, and we'll get to it I promise.

All that being said, here is what I do understand about modules at this level. Modules are sort of your container for the moving parts of you program. Officialy you can say the members of a module include fields (your general data), methods (the object's functions), and properties (the defining characteristics of your object like its name, etc.). The module helps create a unique address for your objects, and if you haven't noticed yet the unique address concept is the central theme to programming in any language.

Modules will also allow other sections of the program to access its objects (assuming the requesting section of the program has permission to access it...that is a whole level unto itself, but it is an important concept).

Like the namespace object, you start and end a module in the following manor:

Module MyModuleName
  Some code here
End Module

That's all the time I've got for today, but we're getting close to being done with the basic parts of the program. Stay tuned for more.

The required nod to the Hello World application – Part 2

Fri, 04 Mar 2011 12:30:04 -0700

Wrote a new blog post in my blog.

Good afternoon all! I like this idea of thinking that I'm talking to a bunch of people as I type this, so I'm just going to go with it as I take my notes. Yesterday I went over how to create a new Console project in Visual Studios, and gave a basic overview of your workspace. Today I would like to start looking at some of the code.

To move ahead quickly, here is the full Hello World program code:

Imports System
Namespace MyHelloWorldApplicationns
    Module MyHelloWorldModule
        Sub Main()
            Console.WriteLine("Hello World")
            Console.ReadLine()
        End Sub
    End Module
End Namespace

You need to understand the second line of code before I can explain the first line, so for now ignore the Imports line.

What is a Namespace?
The Namespace feature in VB.NET is a more detailed naming system. To understand things I like to relate them to real world examples instead of how they relate to other code examples, so let me take a crack at explaining Namespaces this way.

My name is Jarid. I have an odd spelling of the name, so no one mistakes me for the Jared from the Subway commercials, and no one can say they came to me for great jewelry. On paper this is all the the of us would need to know when someone is referring to me instead of one of the famous guys. Spoken our names sound the same, so all 3 of us would look to who was calling us. Enter the last name concept. Mine is Lawson, and while I like to think that back in the day someone earned this name in my family because their father was in law enforcement of some sort (and I can directly relate to that since my father was an officer for 20 years), that is the least important aspect of a last name in my example. Call out in any format - first, last; last, first; a mixture, first, last initial (granted this is less effective because there is a 1 in 26 chance you can have a duplicate still) - it still works to reduce calling 2 people when only 1 is needed.

Computers are less forgiving than humans are when a call for a specific name is made. Whatever the object being called may be - variable, class, function, etc. - no 2 objects can have the same name. If you are working with a large program (thus likely on a large team of programmers) you are likely to have times when the same name is used for 2 classes or 2 variables. Namespaces takes care of that.

Namespaces are the Last Names of an object. The difference in formatting for most Americans is seeing the last name first, but I believe several Asian cultures use this format for the names of their people (or I heard the announcer on G4's Ninja Warrior way wrong...snooge). In any case...my name in object oriented code form would be Lawson.Jarid. If you wanted to refer to the glasses I'm wearing, you could go so far as to say the object Jarid in namespace Lawson now becomes its own Namespace; thus the glasses name would be Lawson.Jarid.Glasses or lAwSoN.jArId.GLasSEs if you want to write it in annoying poser-hacker form.

What this means is a namespace is simply a collection of objects (variables, properties, classes, etc.). The namespaces can have sub or child namespaces, and they can also be part of higher level or parent namespaces. They keep it all in the family. That way when you call MyHellowWorldApplicationns.MyHelloWorldModule, the system knows that is different than YourHelloWorldApplicationns.MyHelloWorldModule.

Ok, these take a little longer than I thought they would to write. I had thought I would get through the entire explanation of the code today, but alas it is not to be. Your assignment, should you choose to accept it, is to take another look at the code, and see it in the namespace identification format that the computer does. Really pay attention to the objects and how they relate to one another, and understand that there are still a ton of subtle concepts shown here that I just haven't been able to get to yet.

Have a great weekend, and I'll see you Monday with the next lesson: The Imports Keyword

The required nod to the Hello World application – Part 1

Thu, 03 Mar 2011 12:37:46 -0700

Wrote a new blog post in my blog.

As basically every programmer will tell you, your first program is your Hello World program, so where else do I start the actual understand of the language than here. As you may or may not know I am learning this language right now, and this blog is where I am keeping my notes so that I have one place to go to for all of the knowledge I have learned. These notes may or may not help others (when I started this blog I didn’t know it was auto set for everyone to be able to read), but if it does help anyone I am grateful I could assist. Please understand I am considering my readers as having at least the basics of how to work a computer…after all, if you’re reading this you by default know how to surf the web. So I won’t tell you where to go to launch programs from. If you don’t know how your Start button works then this is the wrong blog to be looking at right now.

Let’s start by opening Visual Studio. For the record, I’m using Visual Studio 2008 Version 9.0.30729.1 SP on Microsoft .NET Framework Version 3.5 SP1. If you are using a different version of either the code and / or results may be different. The only thing I can tell you is to do what I do, play with it until you figure it out. There are help files both in the application, on the MSDN, and (my personal favorite) Google.com.

This brings up a great ADHD topic hop point (yes, I’ve got it so you’ll have to get used to these little random breaks…just ask my wife…lol). The sort of un-written rule about being an effective code monkey is about to be written: You must be good at researching the web. Programmers not only love to share how they do things, but we also love to steal how other people did something. For the most part we don’t care because if we put it out there we mean for it to be stolen. Personally it satisfies my inner narcissist to know that other people may read what I wrote, and find it worthy enough to steal. You’ll have your own reason, but I’m willing to bet that you will post stuff to. The posting is not the big deal at the beginning; it’s the stealing that counts now. Find how other people did stuff. You’re doing it now, because you’re reading how I learned this language, and you’re stealing my approach. My inner narcissist says, “Thank you! :)”

Ok, back to what we were doing. Open VS, click on File, and then New Project. The left side of the pop up window “Project Types:” should have Visual Basic highlighted. On the right side “Templates:” click once on “Console Application” so that it is highlighted. At the “Name” field near the bottom, change the name to “MyHelloWorldApplication” then click OK.

A window will open with the following:

Module Module1

    Sub Main()

    End Sub

End Module

Let me explain your workspace real quick. You have a Toolbox on the left (this may or may not be expanded…personally I keep mine collapsed unless I need it). Right now this will likely be empty, but this is where you will find the pre-created templates for objects like text boxes, labels, buttons, etc. The center with the code is your main work space. The top right is your Solution Explorer where you can quickly move to different levels of your program (don’t worry, this will be explained later), and the bottom right is your properties window. Your properties window will be used extensively for quick object manipulation if you work in VS like I do. Basically when you drag a new text box from your tool box, and drop it into your work area; the properties window will be where you go to change the name and various other settings of the object.

Gotta run for now, but I will be back soon to continue the lessons.

VB.Net School - .Net Framework - Lesson #1 - Exercise 1 - Quesstion 5

Fri, 14 Jan 2011 11:58:14 -0700

Wrote a new blog post in my blog.

Question: Can system programming such as programming an Operating System or Compiler be done in VB.Net?

Write a 200 - 300 word response:
So I am going to take a low grade on this question (and yes, I'm grading myself, but who cares). My answer even with this initial fluff will not be the full 200 - 300 words, but since I've over answered on others I know my old UOP instructors would not ding me too much (if at all).

Yes it is "possible" to write an OS in VB.Net, but there are so many additional programming steps required it is not something to get into at the start. I'm sure I will try this one day (there is a project I've wanted to work on for YEARS that would require this), but for now I will leave it at this.

VB.Net School - .Net Framework - Lesson #1 - Exercise 1 - Quesstion 4

Thu, 13 Jan 2011 12:20:04 -0700

Wrote a new blog post in my blog.

Question: Microsoft has introduced a new language for the .Net platform called C# with almost all the features that are present in VB.Net. Why should previous VB programmers switch to VB.Net instead of C#.Net? (Especially when VB.Net is so different from VB6 and has introduced so many new concepts)

Write a 200 - 300 word response:
I recently had a programmer begin attempting to teach me .Net development. He no longer works with me, but while he was teaching me he was trying to push C# on me instead of VB. Understand I have written code before now, and the language I fell in love with was VB6. To me it was similar to what HTML was attempting to be...a more human language. It was fairly easy to learn once I got into it, but it was also powerful enough to not force me into new languages. I also attempted to learn C++ back in the day. I was able to create a couple of programs, but the language was a little less readable, and I found VB6 shortly there after.

What does my past programming experience have to do with the discussion question you ask...EVERYTHING. The .Net Framework does not understand VB or C# or Java or any other language we are familiar with. Instead it understands 1 language...MSIL or spelled out the Microsoft Intermediate Language. Visual Studio .Net translates all other .Net compliant languages into MSIL source code, and that source code is then translated into executable machine language at run time. What this means for me and other .Net developers is we can choose which language we want to code in without any real difference in our program's performance.

This is an over generalization of the differences between VB.Net and C#.Net, and I'm sure many could point out some of the minuscule differences in system performance between the two. That being said the choice is going to be based on what you are already familiar with. For me, I love VB already so I'll start with VB.Net. I may eventually learn C#.Net to be able to work with other development shops in the future, and to find some of the different ways to do the same thing...that is more for a personal challenge goal than anything else.

Also, since I just realized last night that other people can see this blog, and newbies maybe reading this...For a new programmer many have said (and I agree with this statement) that VB is easier to pick up at the start than C#. This is a personal preference, but if you are just getting into the field don't try to conquer the world over night. You have to go one step at a time, and VB is a great first step to take.

This is totally off topic, but I want to put this in anyway. I read this when I was learning VB6 back in the day. I wanted to write a video game, and I came across a post that said to start out with the most basic video game you can come up with. Give it a beginning, middle, and end. Write it all the way through, and don't start adding all the bells and whistles that randomly pop into your mind. When your friends start dogging down on your simple but completed video game, and they say they could write something SO much more advanced just smile at them and say, "Really? Where is it?" You can feel good knowing that while they may SAY they can do something you HAVE done something. To quote Barbara Sher, "Doing is a quantum leap from imagining." Just something to keep in mind as you get started.

Count me as one of the forgetful programmers

Thu, 13 Jan 2011 11:45:16 -0700

Wrote a comment' on the blog post 'VB.Net School - .Net Framework - Lesson #1 - Exercise 1 - Quesstion 1'.

VB.Net School - .Net Framework - Lesson #1 - Exercise 1 - Quesstion 3

Wed, 12 Jan 2011 17:18:25 -0700

Wrote a new blog post in my blog.

Question: The term "Disconnected Data Source" is heavily used when talking about ADO.Net. What does it actually mean?

Write a 200 - 300 word response:

I'm going to get ethereal in my answer, so stick with me. This is an extremely visually based description. To define the term Disconnected Data Source, I must also explain what a connected data source is. Think of the connected data source as two people talking on an instant messenger. To continue the conversation both parties must stay connected even if no one has said anything for an hour. If one side drops then a new connection must be established before the conversation can continue. Now think of that same chat happening, only it is using text messaging instead of chat. The only time a connection is made is when one side or the other says something new.

This description is a great way to represent the connected vs. disconnected data source architecture. In a connected source architecture the program is connected directly into the database. It will pass SQL commands to the source tables, and is capable of making direct manipulations on the spot. In obvious form the disconnected data source does not do this.

The disconnected data source architecture uses a go between (this is something that the entire .Net Framework seems to be built around...go betweens) called a Data Adapter. The adapter keeps the connection open only long enough to populate an object called the Data Set. The Data Set is a virtual table structure stored in memory. A program will import data into a Data Set, make all needed updates to the Data Set, and export the Data Set for each SQL transaction. This may sound overly redundant, but it frees up system resources and maintains a higher level of database security. Think about it from the chat vs. text analogy; the chat window must stay up at all times regardless of activity. If someone is able to hack that session then they can read what should be a private conversation. In a similar scenario, someone hacks a specific session during a text message conversation they get 1 message.

VB.Net School - .Net Framework - Lesson #1 - Exercise 1 - Quesstion 2

Wed, 12 Jan 2011 12:35:11 -0700

Wrote a new blog post in my blog.

Question: There are a lot of advantages of using VB.Net and .Net for the developers, but why should a client or a developer jump to VB.Net and .Net? It looks like the user has to additionally insert the .Net Framework in order to run the .Net application. Does it mean that the "Just In Tim Compilation" outweighs the overhead of the .Net Framework with no other apparent benefits?

Write a 200 - 300 word response:

I don't have the time to fully research this right now (I've only got 10 minutes left at lunch), so I know something in the last part of the question is going to reach out and bite me. That being said...

I'm sure there are many more advantages proving the worth of using the .Net Framework, but I want to stay on one aspect of it for now because I'm biased toward the developer view of things. Installing the .Net Framework uses system resources, there is no doubt about that. Adding a picture (even one that Microsoft added as a default setting) to the desktop uses system resources. The question comes down to a cost / benefit analysis.

The amount of system resources used by the .Net Framework pays for itself with something as simple as the garbage collection feature found in the framework. Before .Net a developer had to account for EVERYTHING they used. If one created a variable to store a user's first name, the developer had to make sure (at least on some level) that the RAM devoted to that variable was returned to the system. During the past I have seen developers forget this, and have it cause a system collapse during an end of month sales update. The reason...the RAM was fragmented due to un-used variables not being removed. It cost us a day and a half worth of system time.

The .Net Framework keeps track of things like this in the CRL. While a program is running, the CRL will keep track of all procedures in use and all variables in use. It knows which variables go with which procedures. It knows to keep the global variables available while removing the local variable of a quick procedure that is not being used or referenced anymore. It does all of this using a low priority level process so that it won't impact the overall system performance. In short, it does all of this in its spare time. Pretty cool if you ask me...and totally worth it.

VB.Net School - .Net Framework - Lesson #1 - Exercise 1 - Quesstion 1

Wed, 12 Jan 2011 12:11:54 -0700

Wrote a new blog post in my blog.

Question: All modern compilers do optimization, but in what way are JITers (Just In Time Compilers) different from traditional compilers?

Write a 200 - 300 word response:

The first part of this answer is being written without researching the subject beyond what was provided in lesson 1 already. The text said the JIT would not install sections of code until it was run. I believe this is on a session basis, so once the program is closed then the installed sections go away. The benefit is going to be found in how the user works within the program. When the program is first opened the only system resources being used are what is essential for the basics of the program. More resources will be used as more features in the program are accessed, but once they are accessed once the code does not need to be re-compiled during that session.

This will allow for 2 different benefits, and again each benefit will be tailored to the user interaction. If I open MS Word, and just use it to do a quick spell check then I will be using minimal amounts of my system resources. If however I need to use MS Word to create a detailed document with images and call outs, then when I use each of the needed features the first time the code is installed. Each time I use the feature again, the path is already well established so the call time (and resources needed to call the feature) is reduced.

Conversely a traditional compiler will code / install the features of the program in a one size fits all style. This will mean that more system resources are required during the initial launch of the program as well as the feature call while using the program.

Now I just read a few items on the difference between the two processes. I may or may not be correct in the conclusions I made above, but that is beside the point...I like what I read.

The basic difference between the compiler types can be found in what the source code is compiled into. In the traditional compiler the code is compiled into the machine's executable code. This is great if you are only ever going to run the software on one machine, or even one type of machine. This is bad when you start looking at portability issues.

.Net's JIT will compile it's source code into the Common Intermediate Language (CIL). At runtime, the .Net framework takes the CIL code, and reads it into the machine code with the Common Language Runtime (CLR). The optimization is carried out at runtime with JITers, so the code is optimized for each system it is run on (so the one size fits all vs. tailor made analogy still works...hey, I got something right without research...snooge).

There are additional aspects to the JIT way of doing things. The program no longer talks directly to the OS, but instead uses the CLR as a go between. This may seem like a hit in resources, but since the CLR also handles the memory management, garbage collection, security and thread management the cost is worth it. Traditional compilers forced the programmer to handle some or even all of those aspects, and that is just a pain.