GC.KeepAlive in D and insane stuff

[fakemail at hotmail.com]

==================
My insane thoughts
==================

Definition
----------

All my thoughts actually, sinds I'm insane.
"Type Storage System", yeah I'm just dreaming.

Usage
-----

Hmm, bad idea to use insane thoughts.

====================
Programming Language
====================

Definition
----------
Some structure I format some text in, after which I use it to create a
segmentation fault.

Importing Specific Language files
=================================
import file;

Alias on import
===============
using target=boe;



Including Header files
======================
#include "boe.h"


Procedures and Function overloading
===================================

Defining
--------

Unique procedure names, when defining. When calling them the
ambiguity can automatically be resolved, when in the right
context.
>From C these functions can then easily be called, they
do have a version number declared behind them.

public static class Library
{
public static procedure DoStuff.Double (double a, double b)
{
}
public static procedure DoStuff.Double.1 (double a, double b)
{
}
public static procedure DoStuff.Int (int a, int b)
{
}
public static procedure DoStuff.Whatever (int a, int b)
{
}
public static procedure WriteLine.String (string boe)
{
}
public static procedure WriteLine.Int(in boe)
{
}
}


Usage Source
------------

double a, b;
Library.DoStuff (a,b);		//calls DoStuff.Double.1 the 1 is the version
identifier.


>From C 
------

Darn, this won't work those are managed classes, hmm, how to expose
those to C. No clue.

Library_Add_Double_0 (a, b);
Library_DoStuff_Whatever_0 (c, e);

void Library_WriteLine_String_0(const Compiler_String * boe)
{
}


Operator Overloading
====================

Definition
----------

Less typing, unique procedure or function names.
Maybe get rid of const.

Internals
---------
public class Vector3
{
public static function Vector3 opMul.Vector( const Vector3 a, const Vector3 b)
{
}
public static function Vector3 opMul.Scalar( const double a, const Vector3 b)
{
}
}

Usage
-----
double a; Vector3 b,c;
c=a*b;
c=Vector3.opMul(a,b);
c=Vector3.opMul.Scalar(a,b);

>From C
------
c=Library_Vector3_opMul_Vector_0 (a,b);


Classes
=======

1) Defining classes
-------------------

public class Test
{
private:
int test;
public:
Test(int number)
{
this.test = number;
}
virtual procedure DoStuff(string boe)
{	
}
virtual function int Target()
{
return test;
}
~Test()			//Destructor
{
}
}

2) Using classes
-----------------

Test a;

Test a(10);		//Create instance of class and call constructor on it. Test a = new
Test(10);

Test(10);			//Create an instance of a class with auto naming.


Templates
=========

Definition
----------
Generics are created at runtime and templates
must be templatized at compile time.

Internals
---------

public template class Test.[type T]
{
private:
T boe;
public:
Test (string boe)
{
}
}

public generic class Collections.[type T]
{

}

template class can inherit from a generic class but a
generic class can not inherit from a template
class.

templatize Test.[int];		
templatize Test.[float];
templatize Test.[double];

public procedure string Test.[type T] (T a, T b)
{
return (a+b).ToString();
}

Test(a,b);
Test.[int](a,b)

type boe = Test[int];
boe hello;


Usage
-----

Test.[int] Hello("Assign");
Hello[x] = boe;

TypeWindow
TypeUsage
TypeUsage

ValInt
ValUint

Test.[int]
Test.[float];


Test.[int]	//Warning Test[int] has not been templatized,
//warning templatization occured more than once.

GNOME
-----

__Test();

Library__Library();	//Destructor
Library_Library();	//Constructor	



static interface
=================

Definition
-----------
Serves no other purpose than to give compile time errors and waste disk space. 
Sort of similar to interfaces but you can't pass it as parameter. 


Usage
-----

public static interface DesignApplicationMain
{
public static procedure Main();
}

public static interface class DesignStuff.[type T]
{
}

public class MainClass: DesignApplicationMain
{
public static procedure Main()
{
}
}

public static procedure CannotAsParameter(DesignApplication parameter)		//Error
{
}

static interface and templates
==============================

Definition
----------
Static interfaces can be used with templates.

Usage
-----
public template class Matrix.[StaticInterface T]
{
private T data;			
}



opAppend Operator
=================

Definition
----------
Very special Operator.

The goal is to get rid of HTML, and change them into types.
Sort of new script language.

Limit usage of types defined in scripts can only be stored in
volatile memory.

Internal
--------
public class Body
{
public procedure opAppend.Heading1 (H1 heading) {}
public procedure opAppend.Heading2 (H2 heading) {}
public procedure opAppend.P (P paragraph) {}
}

Usage Source
------------

H1 heading1;
Body {
heading1("The Book");
H2("Chapter 1");
H2("Chapter 2");
}
heading1.Onclick = this.HelloWorld;


XML
===

Xml, get rid of it. It eats up to much space.

From:

<html></html>

To:

Html {
}

And make Html a class type, with methods.

Enforce Names
=============

Events start with Event
------------------------
EventRightMouseButtonDown
EventLeftMouseButtonDown

Member events start with On
---------------------------
public EventRightMouseButtonDown OnRightMouseButtonDown

Enforce virtual or override for members calling an event start with Do
----------------------------------------------------------------------

protected virtual procedure	DoRightMouseButtonDown
{
if (OnRightButtonDown) OnRightButtonDown(self, blabla);
}

Maybe I'm pushing it with this enforcing.

Naming Convention
-----------------
Never MainWindow but WindowMain, FormCustom, AttributeDllImport


Storage Specifier
=================

Definition
----------
Stores a certain type either on the disk or in memory in the current directory, 
visible only from the current computer.

The names of everything stored in there must be unique, everything either
it is stored in disk or in memory.

Usage from Console
------------------

computer permanent int Boe;
computer memory int Hello;


Storage Directory System
========================

Definition
----------
Storage of types and instances of types in permanent
and volatile manner.

Permanent memory is stored on a disk. When a method
is called of a type on the disk a process is startup
to execute the method but that won't be shown in 
the storage system. 

In volatile memory section are stored the instances
of applications that are running. Methods of them
can also be accessed from a remote machine.


Internals
---------

diskonly class ConsoleClass {
console procedure Clear();
}

diskonly class Directory:ConsoleClass
{
diskonly private static string currentPath;

console procedure Add.Directory (Directory directory)
{
}
console procedure ChangeDirectory (string directory)
{
}
}

Usage from Console
------------------

ChangeDirectory ("FirstDirectory");
Clear();	


Console
=======

All the methods of the class Directory can be executed in the current directory.
All other types can be added to a directory.

Although Path can be defined as a string in memory, get rid of it. No more Path.
Scripts starts by defining the path like
using Library.Kernel.Routines;

Oh, Code Completion in the Console, it uses the information from Reflection,
Introspection

In the console, just type everything. Use the mouse or other application if it
becomes to hard. Wussy.

Starting an Application
=======================

Definition
----------

Starts an instance with constructor parameters, these instructions can be
executed
from the console as well from	with the code.

Note the WordApplication can only be started in memory.

Usage from Console
------------------

Applications.WordApplication;				//Auto Naming of instance from console

Applications.WordApplication first;

computer memory Applications.WordApplication first("Mydocument");		//instance
visible on local computer
first.Terminate();

computer memory WordApplication WordApplication; //Error names must be unique.


need something for first &;  //in background. hmm.


ApplicationProject
==================

Definition
----------

Starting up a new application project from the console. Should
be made fairly easily. No make files involved. Everything should
already be included in the Projects.ApplicationProject, if not
you can derive a new type from it.

WordApplicationProject.Compile() of course starts up a new process, but
this is entirely hidden from the user. From the users perspective
it is just a type stored on the disk with a method or procedure
Compile();

Although you can derive from ApplicationProject it is difficult
to modify once the instance is created. Auch.

Usage from Console
------------------

disk Projects.ApplicationProject WordApplicationProject;	
WordApplicationProject.AddSourceFile("");
WordApplicationProject.EditSource("");
WordApplicationProject.Compile();

disk type WordApplication = WordApplicationProject.ExtractApplication;


Documentation
=============

Definition
----------

Provides information for the user and is compiled into the library.
Reflection can get the information out of it. Every method can have 
its own documentation or any type derived from it.

Package, Application, Documentation are all one single package.

Example example1 {
H1("This is an example of how to use Console.WriteLine");
Code("
Console.WriteLine("boe");
");
}


Internals
---------

public class Documentation
{
public procedure opAppend.Header1 (H1 header);
public procedure opAppend.Header2 (H2 header);
}

Usage
-----
Documentation ("This is documentation");
Documentation boe ("This is the actual information");

public procedure Dostuff()
{
public Documentation MyDocumentation
{
H1("First Chapter");
H1("Second Chapter");
P("This is the first
Paragraph and I hope
That it will work"
);
}
public Documentation SecondDocumentation
{
}
}


GtkWindow ("Caption")
{
GtkVBox
{
GtkButton button1;
GtkButton button2;
}
}

Remote Computer
===============

Definition
----------

Define types and store them on a remote machine.
A popup may appear asking the username and password.
This can be executed in the console as well in the
source code. Errors will occur when the type
is not defined on the remote machine.

192.168.0.2 is actually really a fixed location
must be able to replace it with a variable.

Also a type of variable that specifies a location
but that consists of multiple computers. A
Type Storage System over multiple computers.


Usage
-----

remote permanent string 192.168.0.2/Information.Boe = "Hello world";


Transactions
============



Package Maintainers
===================

Definition
----------
Dudes that create packages, we should try to make them go extinct.
Seek way to make them go extinct. (not with weapons)


Type Storage System
===================

Definition
----------
1. Everything stored is a type or instance of a type.
2. Everything in that storage has a unique name.
3. Everything is stored in the default location defined
by the developer.

if Application.WordApplication depends on Library.Kernel.Console
the directory defines it uniquely the package name and path.
No extensions are needed. Console has a type.

Application.InstallationManager.Install("Library.Kernel.Console");
Application.InstallationManager.Install(200.200.200.200/Library.Kernel.Console);

Possibly a layer over the existing file system.

SQL
---

Hmm, try to get rid of it.
array.[int] list = {1,2,3,4,5};
array.[int] numbersSmallerThan3 = list[]; //I don't know, but not SQL.



Stored Procedures
-----------------

The types have methods, use those instead.

//Hmm visual basic seems to be better for sql like methods.
192.168.0.3/thetype.Insert(address="", name="");		//Implement the code for
referential constraints in there.
thetype.Select(1, value<2 );    				//column, expression ??	

Somebody else will figure it out, how this should be done.

GUID
----
Get rid of them. If it clashes just change the name.

Library.Kernel.Boe;
Library.Borland.Boe;
Library.Microsoft.Boe;
Library.Mozilla.Hehe;

Application.Mozilla.MozillaBrowser;


Versioning
==========

Definition
----------

In the type storage system everything is defined uniquely. That is how can we
have
two same types with different versioning. The version follows the name of the
type.

DirectoryMy.0
DirectoryMy.2
DirectoryMy.3

Usage from Console
------------------

ChangeDirectory( "DirectoryMy" );			//Goes to DirectoryMy.3
ChangeDirectory( "DirectoryMy.2" );		//Goes to DirectoryMy.2
CreateDirectory( "DirectoryMy" );			//Already exists error
CreateDirectory( "DirectoryNew" );		//Creates DirectoryMy.0 but if there is only
one
//of them the 0 is not displayed
disk Directory DirectoryNewer;


Stability Level
===============

Definition
----------
Prevent libraries or applications to be linked. A new development
project starts usually at stability level 2. Projects can be started
with higher stability levels,	such as a project to test a library.

Stability level should be automatically modified by the project, from
the moment you link your project your stability level is increased
to the appropriate level.

0		Stable
1		Testing
2		Development				Main development branch starts at dependency level 2
3		Experimental			These are branches of the main development branch


Package with stability level A can depend on packages of stability level B or
lower.
There is a distance of 2 for stability levels.

A			B
-------
0			0
1			0
2			0
3			1
4			2


Dependency Level
================

Prevent libraries or applications to be linked.
There is a distance of 1 for dependency levels.

A			B
-------
1			0
2			1
3			2

Package with dependency level A can depend on packages of dependency level B or
lower.

FUTURE DESIGN PROJECT
=====================

Definition
----------

Define a project called specification. Design project.
a TOP DOWN project of the entire operating system,
starting from a users perspective.

Set up a specification board, that will gather new idea's
of an impossible unrealistic FUTURE operating system and
programming language.

Topaz of GNOME is still too realistic.

Maybe a wikipedia project.

Call it FUTURE DESIGN PROJECT, darn it is already a company I think.




Distributions
=============

Package and library or more or less the same thing. They contain a list of all
dependencies.
and thus also in what directories these dependencies are stored.

How to resolve these?

Library.Kernel.MyLibrary386
Library.Kernel.MyLibraryAMD64

Above obviously suck, different names is a nono.

Distribution.AMD64.Linux.Library.Kernel.MyLibrary
Distribution.i386.Windows.Library.Kernel.MyLibrary

The libraries must be in the correct directory before they can be used at all,
because we
are working with a fixed directory system.

Distributions
=============
Documentation is in the source code. 


Login
=====
User
Defines the user, like Users.Borland.Frederick
Team
Define the what is your function on this system, or team.
(Teams.Administration, Teams.Backup)
Password
Password to enter the function or team.

Team
====

Definition
----------

Team and project managed is fully integrated into the operating system,
to login you must already join a team.

Teams.Borland.DelphiTeam

A: TeamLeader, TeamMember, TeamMember
B: TeamLeader, TeamMember, TeamMember

Deny
Permit
DenyButPermitAllow
AllowButPermitDeny

Like names Teams are structured in a tree. TeamMember can be a Team Owner.
Team Onwer can set permissions.

A user can join multiple teams.

Internals
---------

diskonly class Team
{
console static procedure AddUser() //blabla bla
}


Document Format
===============


Definition
----------
A Document Format based on the types on the system. Thus Html
is a class and so is P,	and any other tag.

Usage
-----

using GreenParagraphs;

P paragraph2;

remote Html HtmlFirst {
paragraph2 ("This is the first Paragraph");
remote P ("This is the second Paragraph");
P ("This is the third Paragraph");
private P boe ("blablabla");
A("Next Page", HtmlSecond, HtmlSecond.paragraph13);
A("Remote Page", "212.165.156.200/HtmlPage");
GreenParagraph("These are in green");
P (
"Wouldn't it be a bit
strange to have the
programming language
and html integrated"
);
GtkWindow("Caption");			//Error could not opAppend GtkWindow to Html HtmlFirst.
}


GtkWindow & window = Windows[x];
GtkWindow window = Windows[x];

GtkWindow[int] & window;

public class GtkWindow
{
private string text;
public procedure Caption(string text)
{
this.text = text;
}
public procedure Caption.Value(string text);
public procedure Caption.Ref(ref string text);
{
this.text = text;	
}
public procedure Caption.Ref.1(ref string text)
{
}
public function string Caption()
{
return test;
}
}

Properties
==========

Definition
----------
The following means exactly the same, if you define the procedure
and the function or the property.

Usage
-----	

public property string Caption {
get {
}
set {
}
}

public procedure Caption( string Caption)
{
}

public function string Caption()
{
}


Arrays
======

Definition
----------
Sort of a template thingy.

Internals
---------

public template TypeArray.[type T]
{
}

Usage
-----
array.[int] boe;
array.[int, 10] boe;
array.[type] MyArray={int, string};

hash.[int, string] boe = {1:"Hello", 2:"Boe"};


Enumerated Types
================

Usage
-----
boe(hello);	//Copy constructor

boe=hello;

string
boe = "terminal";
boe("terminal");

boe=target		//only assigns reference
boe("hehe")		//Creates a new string


public procedure Target() const
{
}


public function string ReturnString.Hehe(string boe)
{
}



Keywords
========

Definition
----------

Special words used by compiler such as function, public, class.
All of them are actually enumerated types.

Compiler.KeyWords.Public
Compiler.KeyWords.Class


Usage
-----

Keywords.Public Keywords.Procedure Target()
{
}

Okay maybe pushing it again, overactive imagination, it serves no purpose.


Disk Memory
===========

perma string OnDiskText;
memory string VolatileText("boe");		//default.
unmanaged pointer int boe;
managed pointer int boe;

OnDiskText = VolatileText;		//Creates a copy or a reference? Eh, a copy right?

VolatileText = OnDiskText;		//Eh pffew. maybe again a copy?


Pointer to memory pointer to disk, instance in memory instance on disk.
= permanew Test();
= new Test();

yeps, I don't know, need to think about this.


Define
======
A is defined using B, B is defined using C, C is defined using A.

Naming Project
==============

Give any object a unique name and classify it. This will
give a name to every possible object, or concept.

To be used in artificial intelligence, in the far future.

Element.Animal.Mamal.Dog.Leg
Element.Animal.Mamal.Cat.Leg
Element.Animal.Mamal.Cat.Leg.LeftFrontLeg
Element.Animal.Mamal.Cat.Leg.LeftBackLeg
Element.Animal.Mamal.Cat.Leg.LeftBackLeg.LeftBackLegOfNeighboursCatSarah
Element.Animal.Mamal.Cat.Leg.FrontLegs


So given the right context Element.Animal.Mamal.Cat.Leg can refer
to the left back leg of Sarah.

Or we could use it in translation software. Instead of typing a document
in English, French, the united nations type it in

Element.Animal.Mamal.Cat

Which than with an automated translator changes to

to: cat
to: kat
to: chat

Of course they can type

using Element.Animal;

on top of their document. :-)

Environment Variables
=====================

Just volatile instantiated types in the Type Storage System. With the naming
convention of the type storage system.


UNIQUE
======

Everything must be uniquely defined, but when using it, given the right context,
ambiguity	can be resolved.

TYPE STORAGE SYSTEM
===================

Eh virtual type system or type storage system or just type database.

Store types and instances of types, either in permanent or volatile.
It can store any type that you made, well ... if you can serialize it. 

Its usual structure is a tree of the class type Directory, which has
methods. ChangeDirectory() is one of them.


STOP TYPING THIS STUPID TEXT
============================

You have been typing for more than 8 hours stop it.
Yes, stop it now.

Sorry for eating up your precious time.


Maybe GNOME guys can implement such a system for GObject?



QUESTION ABOUT D
================

Intro
-----

I've got a question about the D programming language, and I compare it
with what I know, so that will be C#.

In C# when using Platform Invocation Services, (to call C) a managed
type is not fully aware of this.

Handle here is of type int

Code below has a potential error.

public void TestMethod() {
FileStream fileStream = new FileStream("blabla");
PinvokeStuff.PinvokeMethod(fileStream.Handle, "blabla");
}


That is when fileStream is no longer used the garbage collector
can already start deleting the object wile in PinvokeMethod.

Solution1 use GC.KeepAlive
---------

public void TestMethod() {
FileStream fileStream = new FileStream("blabla");
PinvokeStuff.PinvokeMethod(fileStream.Handle, "blabla");
GC.KeepAlive(fileStream);   //or call fileStream.AnotherMethod()
}

Solution2 use of HandleRef
---------

HandleRef keeps a reference to the object.

Question
--------

My Question. What is the method in D? Or how does D handle this?