Progress Report #6

A number of things have changed with regards to the internals. A great deal of time has been spent trying to optimize the engine, resulting in some interesting discoveries.

Continue reading “Progress Report #6”


Floating Objects

Floating new objects are those things you create on the heap and then toss around your program as if they weren’t tied to any particular location. It’s nice to delegate the job of specific object creation to some function and have it return the packaged data with a special interface for accessing only the parts we need. … Or in other words, object factories. Object factories require the heap.

Continue reading “Floating Objects”


To increase speed of the engine, I decided to test what would happen if I made certain numbers built-in. Most people don’t need anything more than integer or double. The other types are only for tasks like saving memory (e.g. making bit-flags) or importing data (which will be handled by a different class in Copper anyways). If you want to save memory, generally you don’t use an interpreted language.
That said, what were the results?
Continue reading “Number^Power”


Rainbow syntax highlighters were created for LISP and related languages, not C++ and imperative languages, but they can be quite useful. Sadly, nothing is easy, and trying to find an IDE that worked on my PC and allowed custom rainbow syntax highlighting proved to be more difficult to find than I imagined. However, I was determined to not write an entire IDE just for syntax highlighting. In fact, I was determined to keep it simple and avoid even having to learn Eclipse (so that I could write an extension). My persistence paid off.

Continue reading “Rainbow()”

pub: private

A number of languages support a kind of “public”/”protected”/”private” model. The actual implementation and meaning of this model vary from programming language to programming language, but the basic idea remains the same: preventing code outside of an object from modifying certain things inside of it.
As an interpreted language, Copper doesn’t support such a model.

Continue reading “pub: private”


This feature was implemented a long time ago and is available on every branch of Copper

Creating classes is an interesting paradigm (should be spelled “paradym”, but nobody asked me). Many languages implement such a feature (C++, Ruby, PHP, etc.), some languages make the feature so terse it’s hard to recognize without reading docs, some languages don’t even bother with it, but you can still implement it with some work. There have been a number of arguments about whether closures and classes are essentially the same thing with different names, but I’m on the side that thinks otherwise. It’s a matter of construction, and certainly closures are far easier to create in some languages than in others. I won’t go into a discussion of class versus closure, but I will admit that the line is certainly very blurry, and Copper adds another dimension to it.

Continue reading “i_am~super”