A Place for Things
My desk is somewhat of a sacred place to me. It’s where I spend a lot of my waking hours. It’s where I do work, play, write these posts, and so much more. I tend to wear out office chairs pretty quickly — not because of my weight or anything, but because I spend so much time at my desk.
For quite a few years, I’ve wanted to design (and eventually, build) what I would consider my ultimate desk. Most importantly, it needs to be functional: I need to be able to put things on it, sit at it, and it needs to give me places to keep the things that I use on a frequent basis close by, in an organized manner. But of course, it’d also be great if it didn’t look too terrible — I look at it quite a bit, after all.
So, how would I go about doing this?
I did what?
When accepting this suggestion, the next two suggested words were ‘of course’.
Thanks, SwiftKey. You know me so well.
Programming Linguistics #6 — Pointing Fingers
Part #5 of this series dove deeper into run-time type information with the type-of operator, and enabled us to have enumerated lists, as well as sequences of characters. Today, we’ll round out the type system by taking a look at unions, pointers, and references.
In addition to structures and classes, we have a third category of composite data types: unions. Unions allow us to access the same memory space in several different ways.
Another feature that we so far have not explored, are pointers and references. Through pointers and references, we can access objects by knowing where they are located, rather than needing to have the entire object on hand.
First, however…
Unions
In some cases, programmers need the ability to access data that is in the same memory location in different ways. The need to do this isn’t very common in a PC environment, but when working on an embedded platform, it often comes up. Having the ability to access the same memory location in multiple ways is often a great help when dealing with things like special function registers.
Programming Linguistics #5 — Type Away
In Programming Linguistics #4, we talked about classes and the type system. This post will expand on those topics a little further.
In the previous post, I spent some time talking about run-time type information. There have been a few points that did not get covered: the type-of operator, the special Any type, enumerations, and strings. Let’s dive into those subjects, shall we?
Programming Linguistics #4 — Back to Class
In part 3 of this series, I’ve talked about what namespaces and functions would look like in my hypothethical programming language. This part will start on the subjects of composite types and run-time type information.
Composite types are an invaluable part of modern programming languages. They allow us to take a collection of related variables and treat them as a single unit, which is great, because not many things can in practice be represented as a single numeric value.
In my language, a distinction would be made between two major variants of composite types: structures and classes. Even though they would be largely the same in terms of how the compiler treats them, there is a semantic difference between the two. Classes are collections of variables (properties) and functions (methods), that support many advanced features like inheritance, overloading, visibility, and so on. Data structures, on the other hand, are merely a collection of variables — they do not have methods, properties are always considered public, and they don’t support inheritance or other more complex features.