Press Kit

From Lazarus wiki
Revision as of 09:31, 18 November 2005 by Neli (talk | contribs) (Typos)

This page is designed for background information for people who want to cover Free Pascal related news. It can be used freely for any use; no copyrights will be claimed.

What is Free Pascal

Free Pascal is an open source Pascal compiler. Work started in 1993 by Florian Klämpfl. Since 1993 Free Pascal has evolved into an advanced piece of technology. Nowadays it is widely considered one best Pascal compilers ever written.

Free Pascal is not just a compiler. The Free Pascal development team writes and maintains:

  • The compiler
  • A runtime library for many operating systems
  • Many software libraries
  • Interfaces to many software libraries written in C
  • An integrated development environment
  • A set of manuals

What is Lazarus

Lazarus is a sister project of Free Pascal. Its aim is to provide an integrated graphical development environment for designing applications. It specializes in creating modern GUI applications at great ease.

The Lazarus team designs and maintains:

  • The Lazarus development environment
  • The Lazarus component library of GUI widgets

Platforms and architectures

Free Pascal is available for the following platforms:

  • 32-bit Dos (GO32V2 dos extender) (Dos support will return in upcoming version 2.0.2)
  • Windows Win32
  • FreeBSD
  • Linux/ARM
  • Linux/i386
  • Linux/powerpc
  • Linux/sparc
  • Linux/x86_64
  • MacOS Classic
  • MacOS X
  • MorphOS
  • Novell Netware
  • OS/2

Free Pascal has also supported the following platforms in the past:

  • AmigaOS/m68000
  • NetBSD/i386
  • NetBSD/m68000
  • Solaris
  • Beos
  • QNX

People are constantly doing experiments with new platforms. It is likely we will be able to Windows CE and Gameboy Advance soon.

Free Pascal programs can usually be recompiled for different platforms without large code changes. Portability is heavily dependand on code architecture, however, the Free Pascal runtime library bridges the gap between Unix (Posix) derived platforms and Dos derived platforms quite well.

Lazarus is available for Linux, Microsoft Windows, and MacOS X. The aim is to make programs useable on all three platforms without code changes.

Possible usages

Free Pascal is flexible, it is useable for a wide range of projects. Examples include:

  • Development of GUI applications
  • Development of operating systems
  • Development of computer games
  • Development of command line tools
  • Development of database applications

Free Pascal also continues the tradition of being a good tool for newcomers to programming.

Compatibility

Free Pascal has native modes where it is highly compatible with Turbo Pascal and Delphi, and special modes where it is extremely compatible. A Mac-Pascal, designed to be compatible with Pascal dialects on Apple platforms also exists. Free Pascal does not implement Extended Pascal.

The Pascal language

The Pascal language has a rich history. It was designed in 1970 by Niklaus Wirth and introduced the concept of structural programming. This revolutionarized programming and the ideas behind it has inspired many other programming languages.

Pascal is a language that has evolved a lot through the years. One of the revolutions inspired by Pascal was byte code, first pioneered in the USCD P-system, today the basis of Java and .NET.

Turbo Pascal introduced another revolution, the Integrated Development Environment. Programs could now be written quicker than ever. Turbo Pascal introduced many enhancement to the Pascal language, including object oriented programming.

While innovations in its successor, Delphi, were not entirely new to the world, Delphi is regarded as one of the best development environments in existance. Delphi enhanced the language as well and prepared it for the next decades.

While Pascal has evolved a lot, it has unmistakenly remained itself and remained close to the original spirit.

The Free Pascal project is dedicated to promote the use of the Pascal language. We are also dedicated to free software. The Free Pascal development team wants to provide the tools that make Pascal an as realistic option as other mainstream languages and believes the use of the Pascal language leads to better software.

Pascal and the programming language universum of today

The programming language spectrum has changed over the years. There are many languages the have come and gone, while other have remained remarkably durable.

There are several reasons why Pascal is still around 35 years after its birth. First, Pascal has adapted very well to new developments. Over the years the language has been extended a lot, and in many cases extended well; Pascal does not feel a crippled language because of its age. These extensions was often done so well that Pascal has beaten "successors" to itself, for example Modula-2. The improvements that these languages provided could be implemented in Pascal as well, which had better tools and provided backward compatibility.

Compatibility is certainly an important reason why Pascal is still around to day. A language vendor that destroys backward compatibility effectively kills all previous investments in that language, making people wonder if they should invest either in the latest hype, or a more stable language.

Managed languages versus unmanaged languages

A lot of hype lately is centered around managed languages, especially Java and .NET. This is partially caused by breakthroughs in the efficiency of those languages, and partially because .NET is supposed to be the next big thing in Windows programming.

Managed languages have their use. By means of byte code, programs written with them can be easily run on multiple processor architectures. Automatic memory management should prevent people from ever having to think about memory references again.

We, the Free Pascal development team, are very sceptical regarding these hypes. We are certain that there will be a role for those languages, but they will not threaten the existance of traditional languages. It should be noted that Pascal has pioneered byte code, but it did not turn out to be a success.

The limitations of manages languages lie in both portability limitations and efficiency limitations. Byte code languages are supposed to be very portable, but they depend on a runtime environment to provide functionality. This runtime environment provides the least common denominator of functionality and often provides it by means of emulation. This puts constraints on available features, and thus limits progress, while emulation provides non-native behaviour.

Efficiency limitations can be found in huge, bloated runtime environments and memory management issues. While automatic memory management removes a burden for the programmer, users are often not pleased to see eating simple programs hundreds of megabytes of memory and don't like sluggish software.

Native applications can provide very tiny tools with very low memory usage. Taking advantage of the platform is easier, because the functionality is already provided.

It is almost certain that there will always be a huge demand for native languages. Keep in mind that, unlike originally promised, the big .NET Windows release, Windows Vista, hardly uses any .NET code. It looks very likely that the Win64 API will be the next big thing in Windows programming, which Free Pascal will of course implement.

C

Which leaves us with C as Pascal's biggest competitor.

The C language has been Pascal's biggest competitor ever since the beginning. Both languages were developed at the same time, offer a very similar programming model, but differ greatly in philosofy.

In the 90's C became more dominant than it ever was. The reason was a lack of good Pascal tools; Turbo Pascal, a 16 bit compiler was discontinued and Delphi was not a universal replacement tool. Today, in the Windows world Pascal still has a healthy market share. In the 90's Pascal vanished from game development (no 32 bit Dos compiler), and later, on Linux, it couldn't compete with C due to lack of good tools. Free Pascal, then heavily in construction, wasn't able to compete seriously.

Pascal is nowadays more competitive against C than ever, it provides a reasonably safe language at comparable performance, better productivity and is nowadays backed by an advanced open source compiler tool.

Why Free Pascal is important

Free Pascal is, to our knowledge, the most advanced open source compiler engine besides the GCC compiler. It can generate speed competitive code, but also implements high level functionality, and extreme compatibility to language dialects.

The compiler is also highly portable and uses an innovative object oriented code generator design, which allows architectures to implement a back-end, but also to override portions of the code generator front end to take advantage of cpu specific features. CPUs with many possible assembler tricks, like the x86 and ARM, benefit greatly from this approach.

Free Pascal is also very friendly to the developer. It compiles fast, many times faster than GCC, and provides clear, helpful error messages. It should also be noted that many programmers will greatly appreciate the extensive documentation. There are also extensive support options for people who are stuck.

The real reason why Free Pascal is important though, is that it solves some of the issues the free software community is currently coping with. Language and development environments make people more productive than in C. More languages promise this, but at a cost for the user of those programs.

Pascal programs are experienced to be fast. They start very quickly (even faster than C programs). They react quickly to user input, and provide good throughput of actual work. Try it: Checkbook Tracker [1] and Pixel32[2] are good examples, and feel the responsiveness.

Lazarus

Lazarus is the most serious free software attempt at providing a full graphical development environment. There are many open source tools and libraries to build GUIs on open source (and proprietary) operating systems, but few do a combination of a full graphical design, full customizability of the actual GUI, full control to the programmer, and all tools you expect in a normal IDE. Add to that the powerful language it is based on and the result is that quality applications can, and are, produced. As a bonus, programs written in Lazarus run on Linux, Windows and MacOS with very little effort.

The result is both very good productivity for the programmer and quality software for the user.

What about other Pascal compilers

Delphi

Delphi is still a superior tool for writing Windows applications. Borland wants to make their flagship product the ideal tool to develop .NET applications. This is done without full backward compatibility. Whether this a good idea is highly doubted by many people in the Pascal world.

Delphi will be influential for the Pascal language for the forseeable time, though.

GNU-Pascal

GNU-Pascal is an attempt to provide a Pascal compiler using the GCC compiler back end. While still active, this compiler has progressed a lot less than Free Pascal. The compiler tried to implement Extended Pascal. While enhancing the original Pascal language considerably, the problem with Extended Pascal is that no code exists in this dialect (and no programmers are being educated to write it), while it is mutually exclusive with the Turbo Pascal and Delphi dialects and their language extensions. This caused an unfortunate effect that no serious code bases existed that this compiler could compile, something which it still is recovering from today.

Rem Objects

This compiler does not implement Pascal, but a Pascal-like language for .NET. It is nice for .NET programmers, but it cannot really compile Pascal code, and also Delphi .NET code cannot be compiled with this compiler.

Virtual Pascal

Virtual Pascal was a great 32-bit compiler with high Turbo Pascal compatibility, used by many Dos and OS/2 programmers to write real world applications. Unfortunately the compiler was written in Turbo Assembler, which made it impossible, or at least very hard, to port to other platforms. When Dos and OS/2 became less popular, Virtual Pascal died.