Nem preciso advinhar porque eu sei em que ele é feito, a interface dele é feia e engessada, por isso prefiro o DBEver ou Beekper Studio (esse tem bem menos recurso, é muito enxuto) Falar da linguagem de uma empresa milionária te machucou não foi? Me desculpe! O Delphi não parou não acredito que a ultima versão que usei dele acho que foi Delphi Sidney ou Rio, não lembro mas foi uma mais nova, bem melhor que as antigas, mas ele melhora a IDE, e continua um Debugger horrível o Debugger do Go é melhor que o do Delphi. (To falando do Go, porque seria humilhação comparar ao do C#) Para quem fala de Java ser verboso, deixa mostra pra vocês uma classe simples de usuário em Delphi. ```pascal type TUsuario = class private FId: Integer; FNome: String; FEmail: String; procedure SetNome(const Value: String); procedure SetEmail(const Value: String); function GetId: Integer; function GetNome: String; function GetEmail: String; public constructor Create(Id: Integer; Nome: String; Email: String); destructor Destroy; override; procedure AlterarNome(NovoNome: String); procedure AlterarEmail(NovoEmail: String); property Id: Integer read GetId write FId; property Nome: String read GetNome write SetNome; property Email: String read GetEmail write SetEmail; end; { TUsuario } constructor TUsuario.Create(Id: Integer; Nome: String; Email: String); begin FId := Id; SetNome(Nome); SetEmail(Email); end; procedure TUsuario.SetNome(const Value: String); begin FNome := Value; end; procedure TUsuario.SetEmail(const Value: String); begin FEmail := Value; end; function TUsuario.GetId: Integer; begin Result := FId; end; function TUsuario.GetNome: String; begin Result := FNome; end; function TUsuario.GetEmail: String; begin Result := FEmail; end; procedure TUsuario.AlterarNome(NovoNome: String); begin SetNome(NovoNome); end; procedure TUsuario.AlterarEmail(NovoEmail: String); begin SetEmail(NovoEmail); end; ``` Obs: esse seria o mundo perfeito, porque a maioria dos devs (que trabalham em projetos legados sim!! nem cria classe, é bem procedural) Ta ai uma coisa que mostra como a construção da linguagem é péssima, vou te dá outro exemplo: Métodos anônimos... Epa, Delphi possuí métodos anônimos, você pode me dizer, mas a construção é tão porca que ele funciona em alguns lugares e não em todos. Vamos lá: Eu tenho um evento de um botão no firemonkey (eu precisei a um tempo atrás), porém eu crio o meu botão em tempo de execução, então quero atribuir o evento de click um método anônimo, eu posso? Não eu não posso! Mas porque? Porque um método anônimo de um evento só permite se for uma construção de método com nome e corpo bem definido, pois ele recebe um parâmetro self que é invisível (essa parte eu não entendi muito bem) Nenhuma linguagem pensou em fazer um novo tipo de método para resolver um problema como métodos anônimos, é rídiculo, não acredita em mim, tudo bem eu tenho fonte de onde eu descobri que não poderia fazer o que tava tentando. [https://en.delphipraxis.net/topic/1047-anon-methods-passed-as-event-handlers/](https://en.delphipraxis.net/topic/1047-anon-methods-passed-as-event-handlers/) # Pra acalmar seu coração de espartano! Eu ainda prefiro o Delphi em comparação ao Lazarus, Lazarus é uma IDE muito fraquinha em comparação, mas dá pra fazer algumas coisinhas. Vlw flw, e estuda o link que mencionei. [https://en.delphipraxis.net/topic/1047-anon-methods-passed-as-event-handlers/](https://en.delphipraxis.net/topic/1047-anon-methods-passed-as-event-handlers/)