I wrote the code here from scratch. The only portion of OpenGL function I use is "drawPixels." All the math and all the programming is my work. I am very proud.

Ambient Lighting

Diffuse Lighting

Phong(Specular) Lighting

Here they are combined nicely.

Texture

Building Blocks

]]> http://www.watchhisbeardgrow.com/posts.php?id=23 enum type {AMBIENT, DIFFUSE, PHONG}; class Light{ public: Light(unsigned int color, float strength, type lightType); unsigned int getColor(); type getType(); virtual void update(vector meshes); protected: type lightType; unsigned int color; float strength; }; Thoughts, anyone? Is there a better way?]]> http://www.watchhisbeardgrow.com/posts.php?id=22 For those who dont know what I am talking about, I will give a quick example: I have a class which contains a reference to another class in the header. The second class I mentioned contains a reference in its header to the first class I mentioned. For each I must include the header of the other class. This causes a "Cyclic Dependencie."

Here is an example of a Forward Declaration:

#ifndef SCENE_H_
#define SCENE_H_
#include 
#include "gui.h"
#include "framebuffer.h"
#include "tmesh.h"
#include "path.h"
#include 

class Light; // THIS IS THE FORWARD DEC.

class Scene {
private:
	FrameBuffer *fb;
	vector meshes;
	PPC *ppc;
	vector lights;
.
.
.
#endif

#include /
#include /
#include /
#include /
#define BUFFER_SIZE 3072

struct sliding_window_buffer{
  int window_start;
  int window_end;
  char *buffer;
}to_application, to_network;

static void init_buffer(struct sliding_window_buffer *swbuffer, int start){
  swbuffer->buffer = (char *)malloc(BUFFER_SIZE);
  assert(swbuffer->buffer);
  swbuffer->window_start = start;
  swbuffer->window_end = swbuffer->window_start;
  for(int i = 0; ibuffer[i] = '\0';
  }
}

static void consume(struct sliding_window_buffer *swbuffer,
		    int bytes, void *ret){
  if(swbuffer->window_start == swbuffer->window_end 
     && swbuffer->buffer[swbuffer->window_start] == '\0' 
     && swbuffer->buffer[swbuffer->window_start+1] == '\0'){
    //IT APPEARS THE BUFFER IS EMPTY, THERE IS NO DATA TO CONSUME
  }
  else{
    //IF THE DATA TO CONSUME DOES NOT CROSS FROM END TO BEGINNING
    if(swbuffer->window_end+bytesbuffer+(swbuffer->window_end%BUFFER_SIZE), bytes);
      //SET THE MOVED DATA TO THE NULL CHARACTER TO EMPTY THE BUFFER
      memset(swbuffer->buffer+(swbuffer->window_end%BUFFER_SIZE), '\0', bytes);
      //MOVE THE END OF THE WINDO TO ITS NEW LOCATION
      swbuffer->window_end = (swbuffer->window_end + bytes)%BUFFER_SIZE;
    }else{
      //THE DATA STARTS AT TH END AND CROSSES TO THE BEGINNING OF THE BUFFER
      //MUST CONSUME IN TWO PARTS AND THEN COMBINE THE PARTS TO RETURN
      void *part_one, *part_two;
      int size_of_part_one = BUFFER_SIZE-swbuffer->window_end;
      int size_of_part_two = bytes-size_of_part_one;
      part_one = malloc(size_of_part_one);
      assert(part_one);
      part_two = malloc(size_of_part_two);
      assert(part_two);
      //GET PEICES
      //THIS RECURSIVE CALL SHOULD TAKE CARE OF MOVING OUR WINDOW
      //AND RESETTING THE BYTES
      consume(swbuffer, size_of_part_one, part_one);
      consume(swbuffer, size_of_part_two, part_two);
      //REASSEMBLE
      memcpy(ret, part_one, size_of_part_one);
      memcpy((char*)ret+size_of_part_one, part_two, size_of_part_two);
      free(part_one);
      free(part_two);
    }
  }
}

static void produce(struct sliding_window_buffer *swbuffer, 
		    int bytes, void *prod){
  //IF THE BYTES TO MOVE ARE NOT TOO LARGE FOR THE BUFFER
  if(byteswindow_start == swbuffer->window_end 
       && swbuffer->buffer[swbuffer->window_start] != '\0' 
       && swbuffer->buffer[swbuffer->window_start+1] != '\0'){
      //IT APPEARS THE BUFFER IS FULL, THERE IS NO ROOM FOR YOUR DATA
    }
    else{
      int space_left;
      //DECIDE HOW TO CALCULATE THE AMOUTN OF SPACE LEFT
      //DEPENDS ON THE ORDER OF THE START AND END OF THE BUFFER
      if(swbuffer->window_end>swbuffer->window_start){
	space_left = swbuffer->window_end-swbuffer->window_start;
      }else{
	space_left = swbuffer->window_end-swbuffer->window_start+BUFFER_SIZE;
      }
      //IF THE BYTES TO MOVE IS GREATER THAN THE SPACE LEFT
      if(bytes > space_left){
	//FIT THE SIZE TO MOVE IN BYTES TO THE SIZE LEFT IN THE BUFFER
	bytes = space_left;
      }
      //IF BYTES WILL FIT BEFORE THE END OF THE BUFFER
      if(bytes+swbuffer->window_startbuffer+swbuffer->window_start, prod, bytes);
      }else{
	//BYTES SPAN FROM END TO BEGIN
	//WILL REQUIRE TWO COPIES
	memcpy(swbuffer->buffer+swbuffer->window_start, 
	       prod, 
	       (BUFFER_SIZE-swbuffer->window_start));
	memcpy(swbuffer->buffer, 
	       (char*)prod+(BUFFER_SIZE-swbuffer->window_start), 
	       bytes-(BUFFER_SIZE-swbuffer->window_start));
      }
      swbuffer->window_start = (swbuffer->window_start+bytes)%BUFFER_SIZE;
    }
  }else{
    printf("ERROR: BYTES ADDED WERE LARGER THAN THE BUFFER");
  }
}

void destroy_buffer(struct sliding_window_buffer *swbuffer){
  free(swbuffer->buffer);
}

int main(){
  //SOME TESTING... NOT STRENUOUS
  init_buffer(&to_application, 200);
  void *half = malloc(strlen("some_bytes")/2);
  consume(&to_application, strlen("some_bytes")/2, half);
  printf("Empty: %s\n", half);  
  void * some_bytes = malloc(strlen("some_bytes"));
  memcpy(some_bytes, "some_bytes", strlen("some_bytes"));
  produce(&to_application, strlen("some_bytes"), some_bytes);
  consume(&to_application, strlen("some_bytes")/2, half);
  printf("first 5: %s\n", half);
  consume(&to_application, strlen("some_bytes")/2, half);
  printf("second 5: %s\n", half);  
  consume(&to_application, strlen("some_bytes")/2, half);
  printf("third 5: %s\n", half);  
  destroy_buffer(&to_application);
  return 0;
}

• Free and Open Source Software(FOSS) in the classroom - The questions I have are along the lines of "What are the implications of exposing open source software to students?", "What are the risks involved?", "How can an educator be sure the students are not picking up bad practices which exist within the current codebase?"
• The Future of the CS1 and CS2 Programming Language - It appears there are many schools using python as a first language. If this is the case, why? What makes this dynamically typed, interpreted language better than what has been used in the past?
• Computing in K12 Education - Something I wrote about recently is my interest in primary and secondary education. I do not believe my K12 education prepared me for my career as a CS student. School systems need our help to promote analytical and computational thought processes. I have an interest in giving back to my community through the promotion of those skills.

Absorption (Conference)

Dissemination (Undergraduate Symposiums)

Now of course this doesn't make too much sense because a calculator probably would not have a menu bar with those particular actions implemented, but I am tired so deal with it...  Anyhow, I think we would all agree that this would be much easier than writing in the Swing API. The syntax is clean and simple. It really only has 3 rules.

1)      New lines with 1 string of text are the definition of a new object/container.

2)      A line which contains 2 strings defines characteristics of the super-container.

3)      Containers can be nested inside of each other.

Now what would the Swing implementation look like?

I don't know about you, but I can safely say I would much rather write a GUI in the DSL I created for designing GUIs, but that was not my initial point. My original point was that Martin Ward states in section 2.1.4 of his paper Language Oriented Programming: "In this case only the lowest level language will need to be ported to a different machine or operating system, and this will be a simple task."

Let's say for example that your Swing implementation needs to be ported to C (unfortunately I can't show the implementation because I am not at all  experienced in creating GUI applications in C), I can only imagine the ported implementation would be just as difficult to write in C as it was is Swing. Martin Fowler gives a good example of translating a DSL into the low level language in his article Generating Code For DSLs.

I don't have any strong conclusions to make on this topic, I just think maybe I am missing something. If you have some insight, please share!

On my adventure into this world of growing interest, I have accumulated a small set of links that I would suggest to everyone with interest in these topics.

Here is that list:

• Martin Fowler's Bliki on DSLs servers as a fantastic springboard into the literature.
• Language Oriented Programming: The Next Programming Paradigm - In particular, pay attention to the information on Language Oriented Programming in general, and steer clear of the specifics about creating DSLs in MPS. Though the information is great, I would not suggest it as part of an introduction to the material.
• Building a DSL in Ruby - This tutorial is a great introduction to Internal DSLs in Ruby. I believe it is greatly simplified but, I have often found that implementing an oversimplified exampled really helps open my mind to the possibilities.

I am really looking forward to delving deeper into these topics. In particular, I want to take a deeper look at Ruby and Functional Programming. It's difficult to see the potential of an internal DSL, taking advantage of the relaxed syntax of Ruby, without having a better understanding of Functional Programming and the interesting semantics of passing functions around to create language structures which are uncommon if not impossible in the Object Oriented Programming Paradigm.

I wanted to make one comment about the industry's interest in Internal DSLs. Though I see why there is so much hype about the topic, I wish the idea of taking advantage of a language's syntax to make understanding code easier was not considered a special focus of the programming languages community. To me, an Internal DSL is nothing more than good programming practice. I think it's the responsibility of the programmer to name functions and variables in a way that best suits the human reader.

I plan on writing an entry specifically about External DSLs so I will refrain from speaking about them for now. I hope I have influenced you to do some reading on these topics. If you have any good articles on topics that you think others or myself would find helpful, please post them for us!