2008-11-19

Simplified 'bitBrave' progress

'bitBrave' code has been successfully ported to console version of the program. I feel much better now using traditional threads instead of wxWidgets timers.

What has to be done to complete this project:

  • Peer information exchange (most of classes already exist)
  • Information extraction to files
Here is how 'bitTorrent' looks now:

Comming soon...

2008-11-09

"bitBrave" simplification

Due to multiple problems with wxWidgets framework, the first version of "bitBrave" is now expected to be a console application. I have spent a lot of time trying to figure out how to solve those problems but the lack of wxWidgets documentation causes spending too much time on it...

The main problem that occured was unhandled exceptions. As I used timers instead of creating my own threads, sometimes code, executed in them, exceeded their intervals. Also, unhandled exceptions occured if timer was activated during dragging the main frame.

When unhandled exception occures, a message box appears allowing to ignore it, but if ignore option is chosen, it looks like some wxWidgets thread dies, because the main frame becomes not draggable and timer stops.

At first I had an idea to stop the timer for as long as timer code execution finishes and then restart it, but it failed as wxWidgets didn't allow me to do that. Also, I tried to catch the exception in many different ways, but it simply didn't work.

At this point, most of bit torrent code is already finished and tested. I still have to create a user interface and several small classes. The first downloadable version is expected to be finished in one to two weeks.

2008-11-06

"bitBrave" project

It looks like it becomes a silly tradition to suspend older projects to be able to work on the new ones... This time I am talking about a "bitBrave" project. This will be a simple freeware or perhaps even open source bit torrent client for Windows platform. I am coding with C++, using wxWidgets framework (with wxDev-C++ IDE).

This is how the main window looks like:

Simple, isn't it?

You just have to put a *.torrent file in a specified directory and the next time you start bitBrave, the download starts automatically. As soon as download finishes, downloaded files appear in another default directory. That is all you need to know to be able to use it!

There are no customisation options, nothing you can change. Just turn it on and wait for data... The main aim is to create as simple and primitive client as it is possible.

Valuable link for bit torrent developers: Bittorrent Protocol Specification

Wait for more info in the near future...

2008-09-01

CMS and OS privacy and future

Both CMS and OS projects are private and neither will be published to the public nor sold in the near future. This blog is designed mainly for those people who participate in these projects. Still, all information here remain public. If you are an outsider, but you find some of my ideas interesting, you may post comments and ask questions. You do not need to be signed in to post those comments at the moment.

CMS:
This software is being developed extremely fast. There is already a tool for creating multilanguage websites, custom class cache mechanism is already working (which was a real headacke recently), there are convenient data validation tools implemented and that is only beginning... Also, it is interesting to note that login screen is already finished.
In the near future this CMS will be used in my company (it does not exist yet) for creating fast and bugless websites.

OS:
My operating system is not being developed at the moment, but there are plans to recreate the booting mechanism in the near future. Using the experiance I gained during my university project, I fell rather self-confident to create a better system. Once again, my first aim will be a brief technical documentation of OS structure and its components.
This project is more like a dream of mine as I am not sure whether anyone will ever use it in the future, but if it happens so, I will try to create a perfect alternative for the modern OS's. I am not an open-sourcer and that means I will not publish the source code. Neither I will give my Operating System for free (as freeware or shareware), but if I will succeed, it will never (you have my word) cost much more than a memory device for its storage (like CD or DVD at the moment). Wish me luck ;)

2008-07-30

CMS meets Smarty

CMS now has a working Smarty template engine integrated. It is already tested and works well. Smarty settings (mostly caching) are automatically set and programmers do not have to care about them. They do not have to think about template addresses as well. In short, programmer only needs to know a few basic functions to work with templates.

Comming-soon tasks:

  • Custom Smarty CMS functions
  • MySQL connection class

2008-07-28

CMS progress and forecast

After a little break (I have been abroad), I am speeding up my CMS development process. I have rewritten all the code comments to fit the requirements of phpDocumentator. At the moment help text is available for all the code written ( without exceptions ).

CMS is expected to become fully operational till the 1st of September. There is still lots of work to be done, but as I am planning to spend 8 hours per day for its development, I have enough reasons to believe that it is absolutely possible to finish CMS on time.

My current tasks are:

  • Finish class dependency detection code ( CMS includes only classes it realy needs )
  • Change the layout of files
  • Modify database to fit the latest ideas
  • Test the system

2008-05-26

Switch back to CMS project

OS presentation was successful. It was said that this OS is an "object oriented operating system that supports event mechanism' (is based on it to be precise). At the moment I have already a working Scheduler, Service Controller and Keyboard driver that supports nearly every key that has ever appeared on standart keyboard in history... My next tasks with OS would be optimising the Scheduler, testing, optimising and updating Service Controller and, of course, I will have to work with other OS components then.

Anyway, I am freezing this project for a while as there is another project waiting to be done and at this point is appears to be more important to me. That is CMS.

So, to sum up, I am switching to CMS project right now. This does not mean that OS project will die here. It will just have to wait for the right time to be continued (finished?).

2008-05-18

Service Controller half finished

The event part of the Service Controller is now finished. Of course, the possibility of bugs in it is still high, but at the moment it seems to be working fine.

When testing the event part of the Service Controller, I have tried to raise the keyboard interrupt and see what happens. This worked well:
1) Interrupt Controller has identified the interrupt and sent message to Scheduler to launch the code.
2) Service Controller, which is responsible for handling such messages, has caught the message and forwarded it to Scheduler.
3) Finally, Scheduler event code was launched.

I am now working on the main code part of Service Controller. It will Schedule sending messages from process to process. The main plan of it has already been developed.

These are my tasks for the nearest future:
1) Finish Service Controller
2) Create a test keyboard code
3) Create a test console output for displaying processes and their states

And this is just the beginning...

2008-05-17

Deadline is comming...

On the 23d of May, 2008 the first OS demonstration will occur. Operating system will not be fully finished by then, but its major functions will already be working.

Current task:
Service Controller.

What has been done since the last post:
- Logo has been created ( it will not be published until the final version of OS )
- Final OS name already exists ( at the moment OS is temporarily named LongWOO )
- Service Controller structure is designed
- Part of Service Controller event code is written

2008-05-09

Multitasking

The main code of Scheduler service has been finished.

Features:
* Priorities;
- Rare priority - run only when other processes are not running;
* Locking;
* Event code vs main code scheduling - supports processes that consist of these two parts;

At the moment this Scheduler is designed for single-processor computers, but its design allows to modify it to support multi-processor architectures rather simply.

The next job is going to be to write a Service controller. Service controller is the main process that implements sending messages between processes. It also supports dinamic libraries. I will discuss this later in my posts.

2008-05-07

Interrupt Controller is half finished

Interrupt Controller consists of two parts (same as every other service): main code and event code. Main code is responsible for handling interrupts and event code is responsible for forwarding new interrupts and handling messages.

Main code of Interrupt Controller is already finished. It does not yet send messages (this feature is temporarily disabled) as there is no Service Controller to handle them. The event code will be created just after Service Controller main code.

At this moment I am developing Scheduler main code for scheduling tasks.

2008-05-06

Boot-load finished!

The second stage bootloader has been finished. It is now able to load all system components from HD (using my own file system). Of course, it does not mean that I will not edit it any more. From time to time I do find some bugs there, but in overal - it works!

Now I am developing an Interrupt Controller. All system interrupts are forwarded to it and then it decides what to do with them. I expect to finish it in a few days. Then I will continue my work by starting writting a scheduler.

2008-04-22

Loading system components (OS)

OS project achievements:
* Working 64bit HD reader procedure
* Paged system information sector
* Paged memory usage array

I am now writting a code which will load system components (they are not present yet), such as scheduler, loader, etc... This is the last OS loading procedure. After this, I will already be able to work in my OS environment.

2008-04-14

RAM scan

As I promised, my OS is now able to gather RAM size all by itself. I have also created a simple check code to dermine whether it is running on Intel (or similar processor) or AMD. In this case (I mean gathering memory size) the main difference is that Intel does not support 64bit pages addressing 64bit memory. Using such pages lead to rather strange effects.

These memory addresses locate the same memory on Intel processors while AMD understands them correctly:

Intel:
0000FFFF00000000h = 0000000000000000h

AMD:
0000FFFF00000000h = 0000FFFF00000000h

At this point I am doing some paging work and very soon the booting process will be finished.

2008-04-08

Operating system becomes long

My operating system is already working fully in long mode (x86-64). The next task will be to scan the actual RAM size and then I will load OS processes into memory. This will be the end of boot procedure and the new OS will alive!..

2008-03-13

Operating system becomes protected

These are the latest OS news (what has been done):
- Gathering RAM size via BIOS
- Reading from HD via I/O ports
- Gathering HD size via I/O ports
- VGA display
- Protected Mode

At this point OS loads a stage-one boot loader, which gathers RAM size and loads a second stage boot loader from file system. Second stage boot-loader gathers HD size, prepares VGA display and goes into PM.

This is it at the moment. Other projects are frozen at the moment.

2008-03-05

Multitasking

There are lots of things I am doing at the same time. That is the main reason why this post was called "Multitasking". The news are as follow:

UPL:
It looks like it is not worth creating a UPL for stand alone programming, although I will continue developing this language for OS programming.

OS:
Boot Loader has been made (first stage only). It loads a second stage boot loader from a file system.

CMS:
No progress at the moment.

2008-01-14

New PHP CMS project temporarily freezes the UPL project

As UPL (U programming language) project is rather huge, I have decided to temporarily freeze it to get some time for the development of a modern CMS, written in PHP. This is definitely not a low level language project but I will need it for my business plans in the future.

What has been done

Basic information about the progress of UPL:
- Project plan (alpha)
- Main language structures
- Main functions
- Middle-code idea

Basic information about the progress of CMS:
- Project plan (beta)
- File hierarchy
- Dynamic class loader with caching
- Some support classes