As promised, Dycapo 0.0.2 is out.
Dycapo will be an open client (mobile)/server system that will improve travel experiences of users in a city. The system will let people to define a destination on their mobile phone. DyCaPo will suggest and arrange trips by either using the Public Transport Service or Carpooling volunteers.
That is, DyCaPo will implement full Dynamic Carpooling functionalities as well as static approaches.
More information and download on the official page.
Here are the release notes and the changes since 0.0.1:
RELEASE NOTES
***************
2010-01-10 Daniel Graziotin
Dycapo 0.0.2 is just for _showing_out_some_functionalities_ of the system and testing the underlying technologies. Dycapo 0.0.2 incorporates and shows:
* OpenTrip Core adoption and OpenTrip Dynamic data structures proposal (in Django Model format)
* Use of XML-RPC with Django (rpc4django over HTTP and HTTPS)
* (Sort of) integration of Dycapo models with Django and rpc4django
* Authentication
* Insertion of a trip by a driver
* Start of a trip by a driver
* Search of a trip by a rider
* Send a ride request to a driver
* Let the driver accept the ride request
No one exported XML-RPC function will surely be included in the final API! No one exported XML-RPC function is either optimized or completely working!
Code is (somewhat) documented. Expect a completely better work for 0.1.0 
CHANGES SINCE 0.0.1
***************
Some refactoring to make the code cleaner.
Lots of bugs fixed.
Test suite rewritten and (finally) fully working.
models.py:
- added utility methods (i.e. __unicode__ and to_xmlrpc)
- use of OpenTrip id proposal instead of Django id
- addition of fields to Participation model, regarding a ride request and a request accepted
trip.py:
this module has been splitted in four files:
- driver.py - holds all the XML-RPC methods that a Driver needs.
- rider.py - holds all the XML-RPC methods that a Rider needs.
- commin.py - will hold all the XML-RPC methods shared by Rider and Driver
- utils.py - holds some utility functions.
driver.py (formerly trip.py):
- added check_ride_requests(trip) - checks for ride requests
- added accept_ride_request(trip, person) - for accepting a Rider
rider.py (formerly trip.py):
- added request_ride(trip) - sends a ride request to a trip
tests/:
- Cleaner code and better organization
- Added test_all_simple.py - creates a Driver and a Rider with the same destination as target
- test_all.py - creates 3 drivers and 5 riders with random locations as target
Related posts
Categories: Carpooling Research Tags: 2010, api, bugs, change, Client, code, daniel, data structures, django, document, Download, driver, DyCaPo, dynamic, dynamic carpooling, dynamic ridesharing, FBK, fix, free software, Free*, gmail, graziotin, how, HTTP, HTTPS, models, OpenTrip, page, pro, promise, protocol, prototype, release, research, Serv, server, SoNet, Wiki, xml-rpc
It’s a pleasure for me to announce Dycapo-0.0.1, the very first release of the project.
Dycapo-0.0.1 is part of the pre-alpha-dontuse releases, to only illustrate some functionalities.
Here are the release notes:
2009-12-26 Daniel Graziotin <daniel DOT graziotin AT gmail DOT com>
Dycapo 0.0.1 is just for showing out some functionalities of the system and
testing the underlying technologies.
Dycapo 0.0.1 incorporates and shows:
- OpenTrip Core adoption and OpenTrip Dynamic data structures proposal (in Django Model format)
- Use of XML-RPC with Django (rpc4django over HTTP and HTTPS)
- (Sort of) integration of Dycapo models with Django and rpc4django
- Authentication
- Insertion of a trip by a driver
- Start of a trip by a driver
- Search of a trip by a rider
- Accepting a ride
No one exported XML-RPC function will surely be included in the final API!
No one exported XML-RPC function is either optimized or completely working!
Code is (somewhat) documented. Expect a completely better work for 0.1.0
You can read much more about Dycapo and download it at Dycapo official project page. Project page also hosts installation instructions and configuration steps.
The research behind Dycapo (Dynamic Carpooling system) is illustrated here.
Related posts
Categories: Carpooling Research Tags: 2009, api, code, configuration, daniel, data structures, django, document, Download, driver, DyCaPo, dynamic, dynamic carpooling, dynamic ridesharing, FBK, free software, gmail, graziotin, how, HTTP, HTTPS, installation, models, OpenTrip, page, pro, project, release, research, SoNet, Wiki, xml-rpc
For the Programming Paradigms course we had to study the concepts of Functional Programming.
So here is my usual mindmap regarding the topic. This is just a summary of the most important concepts of functional programming. It also summarizes the very well-written Functional Programming for the Rest of us publication, and uses its pseudo-Java language.
Topics covered:
- Definition
- Basic Units
- Symbols
- Concurrency
- Higher Order Functions
- Functional Programming and Design Patterns
- Currying
- Lazy Evaluation
- Abstract Control Structures
- Infinite Data Structures
- Continuations
- Pattern Matching
You can reach a browsable HTML export of the mindmap
You can download a PNG export of the mindmap.
You can download FreeMind sources of the mindmap.
Related posts
Categories: Programming, Unibz Tags: 2009, data structures, Design, Download, freemind, functional programming, HTTP, java, javascript, language, mind, mindmap, page, pageTracker, PNG, pro, Programming, programming paradigm, programming paradigms, publication, rest, source, summary, Wiki, wikipedia
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:
// hashMapLinear[] is the hash map
void linearProbingInsert
(int value
){
int probe = hash
(value
);
while (hashMapLinear
[probe
]!=
0){
probe = fmod
((probe
+1),SIZE_HASH_MAP
);
}
hashMapLinear
[probe
] = value;
}
int linearProbingSearch(int value){
int probe = hash(value);
int i;
for(i=0;i<size_hash_map ;i++){
if(hashMapLinear[probe]==value)
return TRUE;
probe = fmod((probe+1),SIZE_HASH_MAP);
}
return FALSE;
}
Download: hash-map-linear-probing.c
The second program is an implementation of a Hash Map with chaining as collision resolution method.
Interesting functions:
// t_hashTableNode is a struct that is created as single linked list
void chainedHashInsert
(int value
){
int probe = hash
(value
);
if(hashMapChained
[probe
] ==
NULL){
hashMapChained
[probe
] = malloc
(sizeof(t_hashTableNode
));
hashMapChained
[probe
]->value = value;
hashMapChained
[probe
]->next =
NULL;
}else{
t_hashTableNode *hashTableNode = hashMapChained
[probe
];
while(hashTableNode->next!=
NULL){
hashTableNode = hashTableNode->next;
}
hashTableNode->next = malloc
(sizeof(t_hashTableNode
));
hashTableNode->next->value = value;
hashTableNode->next->next =
NULL;
}
}
int chainedHashSearch(int value){
t_hashTableNode *hashTableNode = hashMapChained[hash(value)];
while(hashTableNode!=NULL){
if(hashTableNode->value==value){
return TRUE;
}
hashTableNode = hashTableNode->next;
}
return FALSE;
}
Download: hash-map-chaining.c
Related posts
Categories: Programming Tags: address, algorithms, C language, code, data structures, Download, hash, hash map, hash table, HTTP, java, javascript, link, list, page, pageTracker, php, pro, rest, source, source code, Wiki, wikipedia
BD-shell (a.k.a. bdsh) is a tiny Unix shell written in C. It’s a project required for the Operating System Course at my University.
It is written using a clean coding style, following xP coding standard philosophy.
Version 1.0 is the release that satisfies all the course requirements!
Quick Jump:
Features
Download
License
Cool Features
- Lightweight
- Implements real Job Control
- Clear and understandable code, ideal for Academic (and personal) studies
- Makes use of various system calls, signals, signal handlers, user input handling, data structures implementation
- Free Software!
Cool Features NOT present (but may be in future)
- No command history present
- No command/filename auto completion
- No wildcars
- No command piping, just a single command can be launched at a time
- Put everything else here.
Requirements for 1.0.0 (click the arrow)
These are the requirements asked by the teaching professor. The complete project description page is located at
http://www.inf.unibz.it/~david/os/project.html
The shell must be able to do the following:
- to read commands from standard input and execute them in a loop until a
built-in command exit is issued (we call these processes the foreground processes; there is always at most one of these at any particular time);
- be able to redirect the standard input and output of commands by prefixing them with built-in commands in file and out file;
- be able to terminate (involuntarily) the foreground process when user presses ^C and return back to the mini-shell;
- be able to interrupt the foreground process temporarily, when user presses ^Z, returning to the mini-shell;
- be able to execute any number of processes in background (i.e., in parallel with the foreground process), including in particular, the ability to start another process while a process has been temporarily suspended;
- inform the user when the background process finishes or is
waiting for an input from the terminal;
- be able to inform the user what commands are executing in the background by issuing the built-in command jobs, this should include information about the state of the process (i.e., suspended, background, waiting for input, etc.) and about what file(s) is the background process using for standard input and output);
- be able to terminate involuntarily a background processes by issuing the built-in command kill job-number.
- to be able to resume a process or to make a background process into the foreground process (i.e., the one that currently interacts with the terminal) by issuing the fg job-number command.
- 2008-09-14 – version 1.0.0.
- fixed synchronization bug in putJobBackground() that made not notify background processes requesting input (in some situations)
Known Bugs:
- Lots of! I consider bdsh-1.0.0 stable because it covers ALL requirements of the course and does them whell on various Unix systems. So it works, but commands like “in non_existent_file cat” won’t work and will crash it!
What will be next?
- I don’t know. I may consider a 1.0.1 release to fix future bugs. I may also think to add cool features to make the shell complete. I hope I will have the time for it. You can also do it by yourself and send me the code
Old Releases (click the arrow)
- 2008-09-13 – version 1.0.0 Release Candidate 2.
Changes from beta 1 / release candidate 1
- removed gcc O3 flag from makefile
- lots of bugs fixed in functions operating on the list of jobs
- improvements in launchJob() when dealing with background commands
- bug in putJobBackground() that made the shell crash has been fixed
- killJob() now sends a SIGKILL
- bugs fixed in signalHandler_child()
- Code formatted using astyle (linux style)
- A couple of variables renamed
- Various usleep() removed
Known Bugs:
- So many =) This is a shell made for Academic purposes, not for production use!
- 2008-07-30 – version 1.0.0 beta1.
Characteristics:
- First beta release of the final version
- Every requirement has been covered
- Real Job-Control implemented
- About every function of bdsh.c has been rewritten
- New source directory layout, very clean
- Some documentation and makefile
- IMPORTANT! this has to be considered a bug hunting release! Please report me any bugs
-
2008-06-05 – version 0.7.1, corrects the linked list bug of version 0.7.0
- 2008-05-09 – version 0.7.0.
UPDATE 2008-06-05: there is a bug in the list handling, the shell crashes when using the standard input redirection. Please download version 0.7.1, which corrects the problem.
Characteristics:
- Cleaner code!
- Lots of bugs fixed!
- reads commands from standard input and executes them in a loop until a built-in command exit is issued
- redirects STDIN and STDOUT of commands by prefixing them with built-in commands in file and out file
- terminates (involuntarily) the foreground process when user presses ^C and return back to the shell
- executes any number of processes in background (i.e., in parallel with the foreground process)
- informs the user when the background process finishes
- informs the user what commands are executing in the background by issuing the built-in command jobs
- terminates involuntarily a background processes by issuing the built-in command kill job-number.
- Due to a lots of compatibility issues with Gnu/Linux (the shell has been developed under Mac Os X), the final released has been delayed to mid-September. Sorry for this, I encountered so many problems the day before project presentation, that I decided to present it during the next exam session. I switched back to Gnu/Linux, too
-
Final release is scheduled on 2008-06-26, as the project deadline is 2008-06-25. The release will
satisfy all the requirements, and as addition:
- Execution system totally rewritten (e.g. one single short function that handles everything)
- A Job Control will be implemented
- Processes in foreground will really be in foreground, there are a lot of things that we did not learn during the course, like tcsetpgrp()
- Some functions in utils.h will be deleted and optimized
- Cleaner and clearer code!
- 2008-04-21 – version 0.0.1
Characteristics:
-
Modular code, divided in 3 files: bdsh.c, utils.h, headers.h
-
Clean user input from a char buffer to an array of strings
-
Built-in commands: exit (exits from the shell), cd (changes directory), in <filename> command (redirects STDIN of command from <filename>), out <filename> command (redirects STDOUT of command to <filename>)
-
Makes use of fork() to read commands from standard input and execute them
BD-shell is released under The Gnu GPL version 3! This is different from the license of the contents of the blog
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http ://www.gnu.org/licenses/>>.
Related posts
Categories: My Life Tags: academic, aria, background command, BD-shell, Beta, beta release, Blog, bugs, candidate, change, code, data structures, DELETE, document, Download, fix, free software, gpl, HEAD, HTTP, HTTPS, java, javascript, job, layout, link, linux, list, Mac Os, mac os x, page, pageTracker, personal, php, pro, project, PUT, rc2, release, release candidate, report, set, shell, sid, signal handlers, Signals, source, standard, System Calls, Unibz, university, unix, unix shell, URI, variables, version, Wiki, wikipedia
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):
int partition
( int A
[],
int left,
int right
) {
int pivot;
pivot = A
[right
];
while(1){
while( A
[right
] > pivot
){
right–;
}
while( A
[left
] < pivot
){
left++;
}
if( left < right
){
swap
(A,left,right
);
}else{
return left;
}
}
}
void quicksort( int A[], int left, int right){
int m;
if( left < right ) {
m = partition( A, left, right);
quicksort( A, left, m-1);
quicksort( A, m+1, right);
}
}
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.
Related posts
Categories: Programming Tags: algorithms, C language, code, data structures, Design, Download, HTTP, java, javascript, language, page, pageTracker, php, rest, source, source code, version, Wiki, wikipedia
Recent Comments