bodom_lx blog and things|

BD-shell is a project I started about a month ago, which aims to implement a tiny, simple, clean unix shell written in C language. It's an academic project. The Operating Systems Course at my University requires this project as part of the assesment.
I decided to publish the source code and to release it under the GPL, for two reasons:

1. Free software is better! Others can learn something from what I learned
2. Free software is better! I can learn something from what others learned

As always, I accept every kind of suggestions!

Learn more about the project and download the code at this page:
http://bd-things.net/projects/bd-shell/

Time for two new C programs! At the DSA course I learned something about Hash Tables and collision resolutions.
I just implemented insert/search/print operations.

The first source code is an implementation of a Hash Map with open addressing (linear probing) as collision resolution method.
The following are the interesting functions of the program. As always, take a look at the source code for comments:

Download: hash-map-linear-probing.c

The second program is an implementation of a Hash Map with chaining as collision resolution method.
Interesting functions:

Download: hash-map-chaining.c

I'm pleased to publish this insertion sort implementation on single linked lists developed with my collegue Rigel.
It's a nice experiment in asymptotic complexity of O(n^3). The high complexity is due to the necessity of retrieving the neighbours of the node handled, a difficult operation when using single linked lists.

Download: Insertion Sort on Single Linked Lists

As assignment for Data Structures and Algorithms course, we had to work with a modified version of the quicksort algorithm. It came obvious that for modifying a qsort you need to implement it

It is difficult to find a clear quicksort algorithm implemented, so I wrote it.

Here is the generic C implementation of the Quicksort Algorithm, which sorts an array in place, following the Divide And Conquer design.

Download: quicksort qsort in C language

Interesting methods (look at the source code for comments):

As you see, there is nothing optimized in this implementation. It just looks elegant and easy to be understood.
If you would like to have a more optimized version of this algorithm, take a look at this one.

Major Update on 10th April 2009, inclusion of C++ programming language!
Updated on 18th April 2008, a complete example on stack and heap
Updated on 15th April 2008, new contents and new layout!
Updated on 6th April 2008, new contents!

The paper you can download from here is about a model for memory management during the execution of programs written in Java and C++.

It started on March, 2008 as a summary of the lecture notes of both the "Programming Project" and
"Software Engineering Project" courses held by professors of the CASE (Center for Applied Software Engineering) of the Free University of Bolzano - Bozen.

The first versions of this publication were only about Java memory management.
Subsequent revisions added information found on other sources. Unfortunately, the author forgot to
reference the sources on the document.

On March, 2009 the author began to add the information about C++ programming language. More
information from other sources were added, including their attribution.

The biggest source of this document is still the set of presentations of CASE.
The code snippets and their corresponding stack/heap diagrams are copied in full from those of the
slides.

The next major revision will contain original images (not belonging to CASE slides), as well as other code
snippets that I could find more clear than those of CASE.

If you find that this document contains information taken from one of your publications, please
contact the author, that is willing to either delete them from this document or to add an attribution to
your work.

Download the PDF of the summary

Table of Contents:

• The model
• Code load and execution
• Activation Record (AR)
• Contents of the Activation Record
• Abbreviations for
• Declaration vs. Definition
• The scope of a variable
• Extent of a Variable
• Blocks
• Scope Activation Record (SAR)
• Example on SAR
• Role of SLs
• Dynamic Memory Allocation And Handling
• Dynamic Vs. Static memory allocation
• Dynamic Memory Scope and Extent
• Accessing dynamic memory
• Classes
• Objects
• Object instantiation
• Objects in Memory (Java)
• Objects in Memory (C++)
• Memory Management issues (Java)
• Memory Management issues (C++)
• Methods
• Methods (Java)
• Methods (C++)
• Attributes
• The null value (Java)
• The NULL value (C++)
• Parameter
• Parameter Passing (Java)
• Example of parameters passing (Java)
• Example of parameters passing (Java), continued
• Parameter Passing (C++)
• Example of parameters passing by value (C++)
• Example of parameters passing by reference (C++)
• Pointers vs. Parameters (C++)
• Previous example using pointers (C++)
• Constructor
• Inline initialization
• A constructor's call (Java)
• Class attributes
• Example of class attributes (Jav)
• Example of class attributes (C++)
• Class Method
• Example of Stack/Heap Diagrams in Java
• Code
• Stack Diagram
• Heap Diagram

Everything is integrated with simple examples.

Download the PDF of the summary

UPDATE 17:19: it seems that the program I implemented today uses a kind of Bubble Sort algorithm, give it a try, it's quite interesting!

After 3 long days studying C, I think I've assimilated a good knowledge base for the incoming semester.
So there is a tiny C program that sorts the elements of a given integer array, using pointers:

Download the source code (well commented)

A better program should ask the user to input the array elements, and a better algorithm should not scan every array element n times, where n is the number of the elements.
But I wrote it just for fun and for learning C pointers. I will learn to do better in the Data Structures and Algorithms course in the next semester