Publicado RoadMap oficial de Delphi y C++ Builder.
 

Increibles buenas noticias, esperables en la mayoria de los casos, pero con algunas muy buenas excepciones.

lo que me gusta es mucho, particularmente:

Lo que no me gustó:

¿llega tarde, no?

Hay otras cosas que no entiendo que hacen en el roadmap, pues son cosas que ya existen y para quienes no conocen el producto, esto da la idea de que no existiesen actualmente, cosas como:
Esto, entre muchas otras cosas... claro está. :)

Eso me gustaria para fin de año 2007,,

Siempre Delphi llega tarde, está por debajo de MicroSoft. MS tiene ventajas desde que sacó la Tecnologóa .net

CodeGear puso en prioridad lo que sus usarios en mayoria desean, Unicode es prioridad numero uno. Segun lo que han explicado, apenas sea actualizado el CodeGear Studio para trabajar con .Net 2.0/3.0, la atencion sera dedicada unicamente a Unicode y 64 bits nativo.

PDA y CF, realmente no han tenido una gran voz en la comunidad a pesar de que siempre habra alguien que lo quiera y grite por ello.

Es importante notar que ellos a proposito pusieron fechas en terminos MUY generales, segun comentan hay mas chances de sorprendernos con cosas mas rapidas que sorprendernos con retrazos. Si por la vispera se saca el dia, CodeGear ha hecho muy bien desde que se separaron de Borland.

A esperar y seguir programando.

Algunas dudas:
¿Se refiere a soportar el modelo de desarrollo ASP.NET sin utilizar el lenguaje ASP? Es que en ASP no estoy muy puesto.¿Quiere decir esto que van a volver a Linuz? ¿Y a MacOS? ¿Tal vez otros (QNX, OS/400...)? Se ve interesante, si es así.

Por cierto, qué nombres más curiosos les han puesto a los proyectos: Tiburon y Barracuda. Parece que están dispuestos a devorar a Microsoft. :D

a mi me gustaria que fuese, a fin de año lo de hacer programas
para procesadores dual core,

Quizas lo de RIIA un poco por medio de Intraweb (sera que apuntan a una solucion propia??).

Pero lo de multicore? Pa' que entiendas por donde *deberia* de ser la vuelta de la programacion multi-core un vistazo a:

http://erlang.org/doc/doc-5.5.4/doc/...art_frame.html

Y para una explicacion del porque el estilo actual no sirve (y el de erlang si ;) ):

http://www.defmacro.org/ramblings/concurrency.html

Ese es el camino a tomar.


Hace un par de meses intente hacer una implemtacion de erlang concurrency en delphi pero no soy tan hacker y quede a 1/4 de camino :(

Código Delphi [-]
unit ParallelCode;

interface

uses
  {VCL}Classes ,
  {JCL}JclContainerIntf,JclQueues,JclAlgorithms,JclHashMaps;

type
  TBufferType = (tbInt,tbString,tbData);

  IParallelCode = interface
    function GetSession(key: String): TObject;
    procedure SetSession(key: String; const Value: TObject);

    procedure Post(PID:Integer;Value:String);

    procedure BroadCast(PidList: array of Integer;Value:String);overload;
    procedure BroadCast(Value:String);overload;
    procedure Execute;
    procedure Get(FromPID:Integer;Value:String);

    property Session[key:String]:TObject read GetSession write SetSession;

    function GetIsDone: Boolean;
    function GetPid: Integer;
  end;

  TParallelCode = class(TInterfacedObject,IParallelCode)
  private
    FPId : Integer;
    FSession: IJclStrIntfMap;
    FIsDone: Boolean;
    function GetIsDone: Boolean;
    function GetPid: Integer;
    function GetSession(key: String): TObject;
    procedure SetSession(key: String; const Value: TObject);
  protected
    FApply:TApplyFunction;
    FValue:TObject;

    procedure DoPost(PID:Integer;Value:TStream;DataType:TBufferType);virtual;
  public
    procedure Execute;

    procedure Post(PID:Integer;Value:String);

    procedure BroadCast(PidList: array of Integer;Value:String);overload;
    procedure BroadCast(Value:String);overload;

    procedure Get(FromPID:Integer;Value:String);

    property Session[key:String]:TObject read GetSession write SetSession;

    property IsDone:Boolean read GetIsDone;

    property PID:Integer read GetPid;

    constructor Create(Apply:TApplyFunction;Data:TObject;AutoStart:Boolean=True);
    destructor Destroy; override;

end;

implementation

{ TParallelCode }

procedure TParallelCode.BroadCast(PidList: array of Integer; Value: String);
var
  Pid:Integer;
begin
  for Pid in PidList do
  begin
    Post(Pid,Value);
  end;//for
end;

procedure TParallelCode.BroadCast(Value: String);
begin

end;

constructor TParallelCode.Create(Apply: TApplyFunction; Data: TObject;AutoStart:Boolean=True);
begin
  FSession := TJclStrIntfHashMap.Create();

  FApply := Apply;
  FValue := Data;

  if AutoStart then
  begin
    Execute;
  end;
end;

destructor TParallelCode.Destroy;
begin
  Post(-1,'Terminado');

  FSession.Clear;
  FApply := nil;
  FValue := nil;
  inherited;
end;

procedure TParallelCode.DoPost(PID: Integer; Value: TStream;
  DataType: TBufferType);
begin

end;

procedure TParallelCode.Execute;
var
  value:Integer;
begin
  Value := Integer(FApply(FValue));
end;

procedure TParallelCode.Get(FromPID: Integer; Value: String);
begin

end;

function TParallelCode.GetIsDone: Boolean;
begin

end;

function TParallelCode.GetPid: Integer;
begin

end;

function TParallelCode.GetSession(key: String): TObject;
begin
  Result := nil;
end;

procedure TParallelCode.SetSession(key: String; const Value: TObject);
begin

end;

procedure TParallelCode.Post(PID: Integer; Value: String);
var
  Bufer: TStringStream;
begin
  Bufer := TStringStream.Create(Value);

  DoPost(PID,Bufer,tbString);
end;

end.

Código Delphi [-]
unit FastCore2;

interface

uses {VCL} Windows, Classes, Messages ,
     {JCL}JclContainerIntf,JclQueues,JclAlgorithms,JclArrayLists, Coroutine;

type
  TPIdList = array of Integer;

  TForkManager= class(TObject)
  private
    FList: IJclIntfArray;
  public

  end;

  TForkMethod = class(TCoroutine)
  end;

  TFork = class(TObject)
  private
    FPId : Integer;
    FSession: IJclIntfArray;
  protected
    FApply:TApplyFunction;
    FValue:TObject;
    procedure Run;
  public
    property Session:IJclIntfArray read FSession;
    property PID:Integer read FPid;

    procedure Send(PID:Integer;data:String);

    constructor Create(Apply:TApplyFunction;Data:TObject);
    destructor Destroy; override;
  end;

function Fork(TheFunction : TApplyFunction; Data:TObject):TPIdList;
//function Fork(Functions : array of TApplyFunction):TPIdList;overload;

implementation

{Funciones}
function Fork(TheFunction : TApplyFunction;Data:TObject):TPIdList;
begin
  TFork.Create(TheFunction, Data);
end;

{
function Fork(Functions : array of TApplyFunction):TPIdList;
var
  funct: TApplyFunction;
begin
    for funct in Functions do
    begin
      TFork.Create(funct);
    end;

    Result := nil;
end;
}
{ TFork }

constructor TFork.Create(Apply:TApplyFunction;Data:TObject);
begin
  FSession := TJclIntfArrayList.Create();
  FPId := 1;
  FApply := Apply;
  
  Run();
end;

destructor TFork.Destroy;
begin
  inherited;
end;

procedure TFork.Run;
var
  value:Integer;
begin
  Value := Integer(FApply(FValue));
  Send(FPId,'Papa');
end;

procedure TFork.Send(PID:Integer;data: String);
begin

end;

end.

Esto es parte del codigo. La idea era usar el algoritmo de map-reduce (muy famoso por lo de google), corutinas y un API similar al session de asp.net para guardar en memoria con llamadas faciles como:

Código Delphi [-]

Send(FPId=1,Datos);

procedure Process(FromPid,Datos)
begin
//Aqui recibe los mensajes
end;

y luego extender para que funcione por red tambien, a lo erlang.

Quede bloqueado con la parte de como usar los messages de windows y otras cosas...

other operating systems
 

A mí me da especial buen rollo lo de "other operating systems", ya que intuyo que Borland/Codegear quiere dejar de depender tanto de Microsoft tal y como ocurre actualmente, sino que estarían abiertos a más mercados a parte del de Microsoft. También, porque abre un esperanza a que los Linuxeros puedan tener algún día un IDE de una calidad muy alta, cosa que, en mi opinión, no existe ahora, al menos, no con una calidad equiparable a los IDEs de Borland para Windows (aunque Codegear no ha dicho nada de crear IDEs para Linux, únicamente de generar aplicaciones multiplataforma, pero por algo se empieza).
Personalmente, me encantaría poder programar en .NET sin pensar en el sistema operativo final donde correrá la aplicación, ya que me gusta .NET, pero prefiero Linux a Windows (Monodevelop deja mucho que desear en estos momentos y estoy acostumbrado a la sintaxis de Pascal). También ya es hora de que Delphi soporte .NET 2.0 y 3.0, ya que, por ejemplo, las librerias Borland.Provider sólo existen para Windows, por lo que una aplicación pensada para multiplataforma no funciona. Estás obligado a utilizar .NET nativo y entiendo (no he tenido la oportunidad de ratificarlo) que los componentes de conexión a las bases de datos, habrán mejorado en las últimas veriones de .NET... En fin, no me quiero entusiasmar demasiado, pero parece que llegan buenas noticias de mi IDE/Compilador favorito.

eso es una vil y fea copia de JAva.

Eso es totalmente falso, Delphi4 fue el primero en introducir las nuevas caracteristicas del Win98, Delphi7 se anticipo con un preview del .Net, y ahora Delphi2007 da soporte a Vista antes q lo hiciera VS (q aun no se sabe cuando lo va a hacer :confused: ),
eso por nombrar algunas cosas donde Borland se anticipo a M$..

¿Por qué todo el mundoe stá con el Visual Studio .net? Las empresas ya quieren ese cambio. ¿Por qué? ¿Qué le ven en especial?

Estas equivocado, los individuales q conozco cambian a Delphi, y las empresas si cambian es a java..

No. Mi empresa y emrpesas vecinas se apsaron a vS .net 2003. Ahora no se si habrán actualizado. De todas maneras las propias emrpesas, no todas, han dicho ellos mismos que trabajan con .net y lo seguirán haciendo.

Si en realidad es muy interesante pero que no se manden el mismo moco que se mandaron al hacer el kylix para que funcionace unicamente con un rango de kernels especificado, caca caca lo que hizo la gente de borland con el kylix, aunque buena la idea de tener un delhpi para linux.

Borland encontra de M$ mmm... lo dudo mucho.

Saludos